diff --git a/bridge/go-llvm.cpp b/bridge/go-llvm.cpp
index 9d8db39..a6ffb3e 100644
--- a/bridge/go-llvm.cpp
+++ b/bridge/go-llvm.cpp
@@ -141,6 +141,16 @@
   dibuildhelper_->addDebugPrefix(prefix);
 }
 
+void Llvm_backend::setTargetCpuAttr(const std::string &cpu)
+{
+  targetCpuAttr_ = cpu;
+}
+
+void Llvm_backend::setTargetFeaturesAttr(const std::string &attrs)
+{
+  targetFeaturesAttr_ = attrs;
+}
+
 void
 Llvm_backend::verifyModule()
 {
@@ -2456,6 +2466,10 @@
     if (no_return)
       fcn->addFnAttr(llvm::Attribute::NoReturn);
 
+    // attributes for target CPU and features
+    fcn->addFnAttr("target-cpu", targetCpuAttr_);
+    fcn->addFnAttr("target-features", targetFeaturesAttr_);
+
     fcnValue = fcn;
 
     // Fix up references to declaration of old type.
diff --git a/bridge/go-llvm.h b/bridge/go-llvm.h
index 06bf950..ab02d80 100644
--- a/bridge/go-llvm.h
+++ b/bridge/go-llvm.h
@@ -397,6 +397,10 @@
   // Disable frame pointer elimination if set to true.
   void setNoFpElim(bool b) { noFpElim_ = b; };
 
+  // Target CPU and features
+  void setTargetCpuAttr(const std::string &cpu);
+  void setTargetFeaturesAttr(const std::string &attrs);
+
   // Personality function
   llvm::Function *personalityFunction();
 
@@ -818,6 +822,10 @@
 
   // Personality function
   llvm::Function *personalityFunction_;
+
+  // Target cpu and attributes to be attached to any generated fcns.
+  std::string targetCpuAttr_;
+  std::string targetFeaturesAttr_;
 };
 
 #endif
diff --git a/driver/ArchCpusAttrs.h b/driver/ArchCpusAttrs.h
new file mode 100644
index 0000000..7064d9e
--- /dev/null
+++ b/driver/ArchCpusAttrs.h
@@ -0,0 +1,74 @@
+// DO NOT EDIT: this file auto-generated by the following command:
+//
+//    ./capture-fcn-attributes -o ArchCpusAttrs.h -triples x86_64-unknown-linux-gnu
+//
+// in combination with clang:
+//
+//  clang version 7.0.0 (trunk 333637) (llvm/trunk 333650)
+//
+
+typedef struct {
+  const char *cpu;
+  const char *attrs;
+} CpuAttrs;
+
+typedef struct {
+  const char *triple;
+  const CpuAttrs *cpuattrs;
+} TripleCpus;
+
+// triple: x86_64-unknown-linux-gnu
+static const CpuAttrs attrs0[] = {
+  // first entry is default cpu
+  { "x86-64", "+fxsr,+mmx,+sse,+sse2,+x87" },
+  { "amdfam10", "+3dnow,+3dnowa,+fxsr,+lzcnt,+mmx,+popcnt,+prfchw,+sahf,+sse,+sse2,+sse3,+sse4a,+x87" },
+  { "athlon-fx", "+3dnow,+3dnowa,+fxsr,+mmx,+prfchw,+sse,+sse2,+x87" },
+  { "athlon64", "+3dnow,+3dnowa,+fxsr,+mmx,+prfchw,+sse,+sse2,+x87" },
+  { "athlon64-sse3", "+3dnow,+3dnowa,+fxsr,+mmx,+prfchw,+sse,+sse2,+sse3,+x87" },
+  { "atom", "+cx16,+fxsr,+mmx,+movbe,+sahf,+sse,+sse2,+sse3,+ssse3,+x87" },
+  { "barcelona", "+3dnow,+3dnowa,+fxsr,+lzcnt,+mmx,+popcnt,+prfchw,+sahf,+sse,+sse2,+sse3,+sse4a,+x87" },
+  { "bdver1", "+aes,+avx,+cx16,+fma4,+fxsr,+lwp,+lzcnt,+mmx,+pclmul,+popcnt,+prfchw,+sahf,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+sse4a,+ssse3,+x87,+xop,+xsave" },
+  { "bdver2", "+aes,+avx,+bmi,+cx16,+f16c,+fma,+fma4,+fxsr,+lwp,+lzcnt,+mmx,+pclmul,+popcnt,+prfchw,+sahf,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+sse4a,+ssse3,+tbm,+x87,+xop,+xsave" },
+  { "bdver3", "+aes,+avx,+bmi,+cx16,+f16c,+fma,+fma4,+fsgsbase,+fxsr,+lwp,+lzcnt,+mmx,+pclmul,+popcnt,+prfchw,+sahf,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+sse4a,+ssse3,+tbm,+x87,+xop,+xsave,+xsaveopt" },
+  { "bdver4", "+aes,+avx,+avx2,+bmi,+bmi2,+cx16,+f16c,+fma,+fma4,+fsgsbase,+fxsr,+lwp,+lzcnt,+mmx,+mwaitx,+pclmul,+popcnt,+prfchw,+sahf,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+sse4a,+ssse3,+tbm,+x87,+xop,+xsave,+xsaveopt" },
+  { "bonnell", "+cx16,+fxsr,+mmx,+movbe,+sahf,+sse,+sse2,+sse3,+ssse3,+x87" },
+  { "broadwell", "+adx,+aes,+avx,+avx2,+bmi,+bmi2,+cx16,+f16c,+fma,+fsgsbase,+fxsr,+invpcid,+lzcnt,+mmx,+movbe,+pclmul,+popcnt,+prfchw,+rdrnd,+rdseed,+sahf,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave,+xsaveopt" },
+  { "btver1", "+cx16,+fxsr,+lzcnt,+mmx,+popcnt,+prfchw,+sahf,+sse,+sse2,+sse3,+sse4a,+ssse3,+x87" },
+  { "btver2", "+aes,+avx,+bmi,+cx16,+f16c,+fxsr,+lzcnt,+mmx,+movbe,+pclmul,+popcnt,+prfchw,+sahf,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+sse4a,+ssse3,+x87,+xsave,+xsaveopt" },
+  { "cannonlake", "+adx,+aes,+avx,+avx2,+avx512bw,+avx512cd,+avx512dq,+avx512f,+avx512ifma,+avx512vbmi,+avx512vl,+bmi,+bmi2,+clflushopt,+cx16,+f16c,+fma,+fsgsbase,+fxsr,+invpcid,+lzcnt,+mmx,+movbe,+mpx,+pclmul,+pku,+popcnt,+prfchw,+rdrnd,+rdseed,+rtm,+sahf,+sgx,+sha,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave,+xsavec,+xsaveopt,+xsaves" },
+  { "core-avx-i", "+aes,+avx,+cx16,+f16c,+fsgsbase,+fxsr,+mmx,+pclmul,+popcnt,+rdrnd,+sahf,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave,+xsaveopt" },
+  { "core-avx2", "+aes,+avx,+avx2,+bmi,+bmi2,+cx16,+f16c,+fma,+fsgsbase,+fxsr,+invpcid,+lzcnt,+mmx,+movbe,+pclmul,+popcnt,+rdrnd,+sahf,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave,+xsaveopt" },
+  { "core2", "+cx16,+fxsr,+mmx,+sahf,+sse,+sse2,+sse3,+ssse3,+x87" },
+  { "corei7", "+cx16,+fxsr,+mmx,+popcnt,+sahf,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87" },
+  { "corei7-avx", "+aes,+avx,+cx16,+fxsr,+mmx,+pclmul,+popcnt,+sahf,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave,+xsaveopt" },
+  { "goldmont", "+aes,+clflushopt,+cx16,+fsgsbase,+fxsr,+mmx,+movbe,+mpx,+pclmul,+popcnt,+prfchw,+rdrnd,+rdseed,+sahf,+sha,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave,+xsavec,+xsaveopt,+xsaves" },
+  { "goldmont-plus", "+aes,+clflushopt,+cx16,+fsgsbase,+fxsr,+mmx,+movbe,+mpx,+pclmul,+popcnt,+prfchw,+ptwrite,+rdpid,+rdrnd,+rdseed,+sahf,+sgx,+sha,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave,+xsavec,+xsaveopt,+xsaves" },
+  { "haswell", "+aes,+avx,+avx2,+bmi,+bmi2,+cx16,+f16c,+fma,+fsgsbase,+fxsr,+invpcid,+lzcnt,+mmx,+movbe,+pclmul,+popcnt,+rdrnd,+sahf,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave,+xsaveopt" },
+  { "icelake-client", "+adx,+aes,+avx,+avx2,+avx512bitalg,+avx512bw,+avx512cd,+avx512dq,+avx512f,+avx512ifma,+avx512vbmi,+avx512vbmi2,+avx512vl,+avx512vnni,+avx512vpopcntdq,+bmi,+bmi2,+clflushopt,+clwb,+cx16,+f16c,+fma,+fsgsbase,+fxsr,+gfni,+invpcid,+lzcnt,+mmx,+movbe,+mpx,+pclmul,+pku,+popcnt,+prfchw,+rdpid,+rdrnd,+rdseed,+rtm,+sahf,+sgx,+sha,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+vaes,+vpclmulqdq,+x87,+xsave,+xsavec,+xsaveopt,+xsaves" },
+  { "icelake-server", "+adx,+aes,+avx,+avx2,+avx512bitalg,+avx512bw,+avx512cd,+avx512dq,+avx512f,+avx512ifma,+avx512vbmi,+avx512vbmi2,+avx512vl,+avx512vnni,+avx512vpopcntdq,+bmi,+bmi2,+clflushopt,+clwb,+cx16,+f16c,+fma,+fsgsbase,+fxsr,+gfni,+invpcid,+lzcnt,+mmx,+movbe,+mpx,+pclmul,+pconfig,+pku,+popcnt,+prfchw,+rdpid,+rdrnd,+rdseed,+rtm,+sahf,+sgx,+sha,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+vaes,+vpclmulqdq,+wbnoinvd,+x87,+xsave,+xsavec,+xsaveopt,+xsaves" },
+  { "ivybridge", "+aes,+avx,+cx16,+f16c,+fsgsbase,+fxsr,+mmx,+pclmul,+popcnt,+rdrnd,+sahf,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave,+xsaveopt" },
+  { "k8", "+3dnow,+3dnowa,+fxsr,+mmx,+prfchw,+sse,+sse2,+x87" },
+  { "k8-sse3", "+3dnow,+3dnowa,+fxsr,+mmx,+prfchw,+sse,+sse2,+sse3,+x87" },
+  { "knl", "+adx,+aes,+avx,+avx2,+avx512cd,+avx512er,+avx512f,+avx512pf,+bmi,+bmi2,+cx16,+f16c,+fma,+fsgsbase,+fxsr,+lzcnt,+mmx,+movbe,+pclmul,+popcnt,+prefetchwt1,+prfchw,+rdrnd,+rdseed,+rtm,+sahf,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave,+xsaveopt" },
+  { "knm", "+adx,+aes,+avx,+avx2,+avx512cd,+avx512er,+avx512f,+avx512pf,+avx512vpopcntdq,+bmi,+bmi2,+cx16,+f16c,+fma,+fsgsbase,+fxsr,+lzcnt,+mmx,+movbe,+pclmul,+popcnt,+prefetchwt1,+prfchw,+rdrnd,+rdseed,+rtm,+sahf,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave,+xsaveopt" },
+  { "nehalem", "+cx16,+fxsr,+mmx,+popcnt,+sahf,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87" },
+  { "nocona", "+cx16,+fxsr,+mmx,+sse,+sse2,+sse3,+x87" },
+  { "opteron", "+3dnow,+3dnowa,+fxsr,+mmx,+prfchw,+sse,+sse2,+x87" },
+  { "opteron-sse3", "+3dnow,+3dnowa,+fxsr,+mmx,+prfchw,+sse,+sse2,+sse3,+x87" },
+  { "penryn", "+cx16,+fxsr,+mmx,+sahf,+sse,+sse2,+sse3,+sse4.1,+ssse3,+x87" },
+  { "sandybridge", "+aes,+avx,+cx16,+fxsr,+mmx,+pclmul,+popcnt,+sahf,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave,+xsaveopt" },
+  { "silvermont", "+aes,+cx16,+fxsr,+mmx,+movbe,+pclmul,+popcnt,+prfchw,+rdrnd,+sahf,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87" },
+  { "skx", "+adx,+aes,+avx,+avx2,+avx512bw,+avx512cd,+avx512dq,+avx512f,+avx512vl,+bmi,+bmi2,+clflushopt,+clwb,+cx16,+f16c,+fma,+fsgsbase,+fxsr,+invpcid,+lzcnt,+mmx,+movbe,+mpx,+pclmul,+pku,+popcnt,+prfchw,+rdrnd,+rdseed,+rtm,+sahf,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave,+xsavec,+xsaveopt,+xsaves" },
+  { "skylake", "+adx,+aes,+avx,+avx2,+bmi,+bmi2,+clflushopt,+cx16,+f16c,+fma,+fsgsbase,+fxsr,+invpcid,+lzcnt,+mmx,+movbe,+mpx,+pclmul,+popcnt,+prfchw,+rdrnd,+rdseed,+rtm,+sahf,+sgx,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave,+xsavec,+xsaveopt,+xsaves" },
+  { "skylake-avx512", "+adx,+aes,+avx,+avx2,+avx512bw,+avx512cd,+avx512dq,+avx512f,+avx512vl,+bmi,+bmi2,+clflushopt,+clwb,+cx16,+f16c,+fma,+fsgsbase,+fxsr,+invpcid,+lzcnt,+mmx,+movbe,+mpx,+pclmul,+pku,+popcnt,+prfchw,+rdrnd,+rdseed,+rtm,+sahf,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave,+xsavec,+xsaveopt,+xsaves" },
+  { "slm", "+aes,+cx16,+fxsr,+mmx,+movbe,+pclmul,+popcnt,+prfchw,+rdrnd,+sahf,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87" },
+  { "tremont", "+aes,+cldemote,+clflushopt,+cx16,+fsgsbase,+fxsr,+gfni,+mmx,+movbe,+movdir64b,+movdiri,+mpx,+pclmul,+popcnt,+prfchw,+ptwrite,+rdpid,+rdrnd,+rdseed,+sahf,+sgx,+sha,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+waitpkg,+x87,+xsave,+xsavec,+xsaveopt,+xsaves" },
+  { "westmere", "+aes,+cx16,+fxsr,+mmx,+pclmul,+popcnt,+sahf,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87" },
+  { "znver1", "+adx,+aes,+avx,+avx2,+bmi,+bmi2,+clflushopt,+clzero,+cx16,+f16c,+fma,+fsgsbase,+fxsr,+lzcnt,+mmx,+movbe,+mwaitx,+pclmul,+popcnt,+prfchw,+rdrnd,+rdseed,+sahf,+sha,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+sse4a,+ssse3,+x87,+xsave,+xsavec,+xsaveopt,+xsaves" },
+  { "", "" } // sentinel
+};
+
+const TripleCpus triples[] = {
+  { "x86_64-unknown-linux-gnu", &attrs0[0] },
+  { "", nullptr } // sentinel
+};
diff --git a/driver/CompileGo.cpp b/driver/CompileGo.cpp
index 95d1696..e86a726 100644
--- a/driver/CompileGo.cpp
+++ b/driver/CompileGo.cpp
@@ -26,6 +26,10 @@
 #include "Driver.h"
 #include "ToolChain.h"
 
+namespace gollvm { namespace arch {
+#include "ArchCpusAttrs.h"
+} }
+
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
@@ -99,6 +103,8 @@
   std::string asmOutFileName_;
   std::unique_ptr<ToolOutputFile> asmout_;
   std::unique_ptr<TargetLibraryInfoImpl> tlii_;
+  std::string targetCpuAttr_;
+  std::string targetFeaturesAttr_;
 
   void createPasses(legacy::PassManager &MPM,
                     legacy::FunctionPassManager &FPM);
@@ -374,9 +380,9 @@
     return false;
   Options.AllowFPOpFusion = *dofuse;
 
-  // Support -mcpu
+  // Support -march
   std::string cpuStr;
-  opt::Arg *cpuarg = args_.getLastArg(gollvm::options::OPT_mcpu_EQ);
+  opt::Arg *cpuarg = args_.getLastArg(gollvm::options::OPT_march_EQ);
   if (cpuarg != nullptr) {
     std::string val(cpuarg->getValue());
     if (val == "native")
@@ -385,16 +391,45 @@
       cpuStr = cpuarg->getValue();
   }
 
-  // Features.
-  // FIXME: incorporate command line flags.
-  SubtargetFeatures features;
-  features.getDefaultSubtargetFeatures(triple_);
-  std::string featStr = features.getString();
+  // Locate correct entry in architectures table for this triple
+  const gollvm::arch::CpuAttrs *cpuAttrs = nullptr;
+  for (unsigned i = 0; gollvm::arch::triples[i].cpuattrs != nullptr; i += 1) {
+    if (!strcmp(triple_.str().c_str(), gollvm::arch::triples[i].triple)) {
+      cpuAttrs = gollvm::arch::triples[i].cpuattrs;
+      break;
+    }
+  }
+  if (cpuAttrs == nullptr) {
+    errs() << progname_ << ": unable to determine target CPU features for "
+           << "target " << triple_.str() << "\n";
+    return false;
+  }
+
+  // If no CPU specified, use first entry. Otherwise look for CPU name.
+  if (!cpuStr.empty()) {
+    bool found = false;
+    while (strlen(cpuAttrs->cpu) != 0) {
+      if (!strcmp(cpuAttrs->cpu, cpuStr.c_str())) {
+        // found
+        found = true;
+        break;
+      }
+      cpuAttrs++;
+    }
+    if (!found) {
+      errs() << progname_ << ": invalid setting for -march:"
+             << " -- unable to identify CPU '" << cpuStr << "'\n";
+      return false;
+    }
+  }
+  targetCpuAttr_ = cpuAttrs->cpu;
+  targetFeaturesAttr_ = cpuAttrs->attrs;
 
   // Create target machine
   Optional<llvm::CodeModel::Model> CM = None;
   target_.reset(
-      TheTarget->createTargetMachine(triple_.getTriple(), cpuStr, featStr,
+      TheTarget->createTargetMachine(triple_.getTriple(),
+                                     targetCpuAttr_, targetFeaturesAttr_,
                                      Options, driver_.reconcileRelocModel(),
                                      CM, cgolvl_));
   assert(target_.get() && "Could not allocate target machine!");
@@ -435,6 +470,8 @@
     return false;
   bridge_->setTraceLevel(*tl);
   bridge_->setNoInline(args_.hasArg(gollvm::options::OPT_fno_inline));
+  bridge_->setTargetCpuAttr(targetCpuAttr_);
+  bridge_->setTargetFeaturesAttr(targetFeaturesAttr_);
 
   // -f[no-]omit-frame-pointer
   bool omitFp =
diff --git a/driver/Driver.cpp b/driver/Driver.cpp
index d7893f2..529ca1b 100644
--- a/driver/Driver.cpp
+++ b/driver/Driver.cpp
@@ -289,18 +289,6 @@
   else
     triple_ = Triple(sys::getDefaultTargetTriple());
 
-  // Support -march
-  std::string archStr;
-  opt::Arg *archarg = args_.getLastArg(gollvm::options::OPT_march_EQ);
-  if (archarg != nullptr) {
-    std::string val(archarg->getValue());
-    if (val == "native")
-      archStr = sys::getHostCPUName();
-    else
-      archStr = archarg->getValue();
-    triple_.setArchName(archStr);
-  }
-
   // Honor -dumpmachine
   if (args_.hasArg(gollvm::options::OPT_dumpmachine)) {
     llvm::outs() << triple_.str() << "\n";
diff --git a/driver/capture-fcn-attributes.go b/driver/capture-fcn-attributes.go
new file mode 100644
index 0000000..c3b64f4
--- /dev/null
+++ b/driver/capture-fcn-attributes.go
@@ -0,0 +1,551 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//
+// This bootstrap helper program emits C++ code that encapsulates
+// information about available CPUs for a given architecture. It works
+// by invoking clang and/or llc and inspecting trace output and
+// generated IR.   Note: the expectation is that this program will be
+// built and run "off line" to generate a header file that is then
+// checked in (as opposed to having it build and run as part of the
+// actual gollvm ninja/cmake build).
+//
+// The intent is to allow gollvm to support the "-march=XXX" flag in a
+// basic way without having to recreate/replicate all of the
+// architecture-specific machinery in the clang driver that deals
+// with feature flags and feature attributes for the available targets
+// (since this code is very complex).
+//
+// This general idea is that for a given target triple we want to
+// determine the set of legal values that can be supplied to
+// the -march=XXX command line option, along with the correct set
+// of feature attributes that apply for that cpu/arch (settings for
+// -mattr=YYY,ZZZ,...).
+//
+// The strategy is to first run clang and/or LLC using command line
+// options whose output (or error messages) list out available CPU
+// settings (either "llc -mcpu=help" or "clang -march=Illegal"
+// depending). Once the set of available CPUs is populated, we then
+// run clang with -emit-llvm and inspect the generated IR to collect
+// the set of attributes for each arch/cpu.
+//
+// Notes:
+// - not all versions of clang will produce a list of legal arch/cpu
+//   values when presented with an illegal -march value (this seems to be
+//   a recent development); this trick also doesn't seem to work
+//   when cross compiling (suppling --target=XXX to clang). For the
+//   cross-compile case, we fall back on running "llc".
+// - confusingly, llc's set of available CPUs is different
+//   from clang's available set of CPUs, so there has to be some
+//   weeding out of extra CPU names in some cases.
+//
+// Representative usage:
+//
+// % go build capture-fcn-attributes
+// % export PATH=<llvm bin dir>:$PATH
+// % ./capture-fcn-attributes -o HeaderFile.h -triples x86_64-unknown-linux-gnu
+// %
+
+package main
+
+import (
+	"bufio"
+	"flag"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+const prog = `
+#include <inttypes.h>
+typedef struct  {
+  uint64_t a[512];
+  uint64_t b[512];
+  uint64_t c[512];
+} vstuff;
+void Add512(vstuff *v) {
+  for (unsigned i = 0; i < 512; ++i) {
+    v->c[i] = v->a[i] + v->b[i];
+  }
+}
+`
+
+var (
+	noclflag      = flag.Bool("noclean", false, "Don't clean temp dir")
+	verbflag      = flag.Int("v", 0, "Verbose trace output level")
+	cpuflag       = flag.String("cpu", "", "Generate for specified cpu or cpus")
+	triplesflag   = flag.String("triples", "", "Select target triple(s)")
+	outfileflag   = flag.String("o", "", "Output file")
+	exitst        int
+	defaultTriple string
+)
+
+func verb(vlevel int, s string, a ...interface{}) {
+	if *verbflag >= vlevel {
+		fmt.Printf(s, a...)
+		fmt.Printf("\n")
+	}
+}
+
+func warn(s string, a ...interface{}) {
+	fmt.Fprintf(os.Stderr, s, a...)
+	fmt.Fprintf(os.Stderr, "\n")
+	exitst = 1
+}
+
+func fatal(s string, a ...interface{}) {
+	log.Fatalf(s, a...)
+}
+
+func usage(msg string) {
+	if len(msg) > 0 {
+		fmt.Fprintf(os.Stderr, "error: %s\n", msg)
+	}
+	fmt.Fprintf(os.Stderr, "usage: capture-fcn-attributes [flags]\n")
+	flag.PrintDefaults()
+	os.Exit(2)
+}
+
+type result struct {
+	cpu       string
+	attrs     string
+	supported bool
+	def       bool
+}
+
+func tb(x bool) int {
+	if x {
+		return 1
+	}
+	return 0
+}
+
+type ByCpu []result
+
+func (a ByCpu) Len() int      { return len(a) }
+func (a ByCpu) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
+func (a ByCpu) Less(i, j int) bool {
+	if a[i].def != a[j].def {
+		return tb(a[j].def) < tb(a[i].def)
+	}
+	return a[i].cpu < a[j].cpu
+}
+
+var qurx = regexp.MustCompile(`^"(.+)"$`)
+
+func qutrim(s string) string {
+	sl := qurx.FindStringSubmatch(s)
+	if len(sl) == 2 {
+		return string(sl[1])
+	}
+	return s
+}
+
+// Attributes strings are of the form { X Y Z=W A=B "Q"="R" ... }
+
+func parseAttrs(raw string) (string, string) {
+	fields := strings.Fields(raw)
+	features := ""
+	cpu := ""
+	for _, f := range fields {
+		sl := strings.Split(f, "=")
+		if len(sl) != 2 {
+			continue
+		}
+		k, v := qutrim(sl[0]), qutrim(sl[1])
+		if k == "target-features" {
+			features = v
+		} else if k == "target-cpu" {
+			cpu = v
+		}
+	}
+	return cpu, features
+}
+
+// Function definitions in an LLVM IR dump have an attribute tag (#<num>);
+// we then look for an attribute declaration with the same number later
+// in the dump.
+
+func parseClangOut(r io.Reader) (string, string) {
+
+	// function def:
+	//    define dso_local void @Add512(%struct.vstuff*) #0 {
+	fcnr := regexp.MustCompile(`^define.*@Add512\(.*\)\s+#(\d)\s+{\s*$`)
+
+	// function attrs:
+	// attributes #0 = { nounwind uwtable "x"="y" .... }
+	attrr := regexp.MustCompile(`^attributes\s+#(\d+)\s+\=\s+{(.+)\}\s*$`)
+
+	rawattrs := ""
+	attrnum := int64(-1)
+	scanner := bufio.NewScanner(r)
+	for scanner.Scan() {
+		verb(3, "clangline is %s", scanner.Text())
+		sl := fcnr.FindSubmatch(scanner.Bytes())
+		if len(sl) == 2 {
+			at, serr := strconv.ParseInt(string(sl[1]), 10, 64)
+			if serr != nil {
+				fatal("problems matching %s in %s",
+					string(sl[1]), scanner.Text())
+			}
+			attrnum = at
+			verb(3, "=> attrnum is %d", attrnum)
+		}
+		if attrnum != int64(-1) {
+			sl := attrr.FindSubmatch(scanner.Bytes())
+			if len(sl) == 3 {
+				at, serr := strconv.ParseInt(string(sl[1]), 10, 64)
+				if serr != nil {
+					fatal("problems matching %s in %s",
+						string(sl[1]), scanner.Text())
+				}
+				verb(3, "=-= at = %v\n", at)
+				if at == attrnum {
+					rawattrs = string(sl[2])
+					verb(3, "=> found rawattrs %s", rawattrs)
+					break
+				}
+			}
+		}
+	}
+	if scanner.Err() != nil {
+		fatal("error scanning clang output: %v", scanner.Err())
+	}
+
+	if rawattrs == "" {
+		fatal("unable to locate fcn attrs in clang output")
+	}
+	return parseAttrs(rawattrs)
+}
+
+func parseClangOutFile(cloutfile string) (string, string) {
+	infile, err := os.Open(cloutfile)
+	if err != nil {
+		fatal("problems opening clang output file %s: %s", cloutfile, err)
+	}
+	return parseClangOut(infile)
+}
+
+// For debugging (not needed for final output)
+
+func emitClangCmdLine(tdir string, cpu string, clargs []string) {
+	f := filepath.Join(tdir, fmt.Sprintf("%s.clangcmd.txt", cpu))
+	outfile, err := os.OpenFile(f, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666)
+	if err != nil {
+		fatal("unable to open trace output file %s", f)
+	}
+	bw := bufio.NewWriter(outfile)
+	bw.WriteString("clang")
+	for _, arg := range clargs {
+		bw.WriteString(" ")
+		bw.WriteString(arg)
+	}
+	bw.WriteString("\n")
+	if err := bw.Flush(); err != nil {
+		fatal("error writing file %s: %v", f, err)
+	}
+	if err := outfile.Close(); err != nil {
+		fatal("error closing output file %s: %v", f, err)
+	}
+}
+
+func enumerateAttributes(triple string, tdir string, cpus []string, bw *bufio.Writer, tf string, idx int) {
+
+	verb(1, "enumerating attributes for %d cpus", len(cpus))
+
+	// First entry in the list needs to be the default CPU
+	ecpus := append([]string{""}, cpus...)
+
+	// Process the various CPUs in parallel
+	sema := make(chan struct{}, runtime.NumCPU()) // limit concurrency
+	rchan := make(chan result, runtime.NumCPU())
+	for _, cpu := range ecpus {
+		verb(1, "enumerate for cpu %s", cpu)
+
+		go func(cpu string) {
+			sema <- struct{}{}
+			defer func() {
+				<-sema
+			}()
+
+			// Invoke clang with proper arguments
+			lloutfile := filepath.Join(tdir, fmt.Sprintf("%s.ll", cpu))
+			clargs := []string{"-emit-llvm", "-S", "-o", lloutfile,
+				"-O3", "-Xclang", "-disable-llvm-passes", tf}
+			cpuarch := "arch"
+			if triple != "" {
+				clargs = append(clargs, fmt.Sprintf("--target=%s", triple))
+			}
+			if triple != defaultTriple {
+				cpuarch = "cpu"
+			}
+			if cpu != "" {
+				clargs = append(clargs, fmt.Sprintf("-m%s=%s", cpuarch, cpu))
+			}
+			emitClangCmdLine(tdir, cpu, clargs)
+			cmd := exec.Command("clang", clargs...)
+			output, cerr := cmd.CombinedOutput()
+			if cerr != nil {
+				if triple == "" {
+					warn("clang run failed: %s", output)
+					fatal("err = %v", cerr)
+				}
+				// Note the 'supported:false' (indicating that this CPU
+				// value is not viable).
+				rchan <- result{cpu: cpu, attrs: strings.Join(clargs, " "), supported: false, def: false}
+			} else {
+				// Sift through the output for attr set.
+				acpu, attrs := parseClangOutFile(lloutfile)
+				adef := false
+				if cpu == "" {
+					adef = true
+				}
+
+				// Send results on to the consume.
+				rchan <- result{cpu: acpu, attrs: attrs, supported: true, def: adef}
+			}
+		}(cpu)
+	}
+
+	// Read raw results.
+	visited := make(map[string]bool)
+	results := []result{}
+	for range ecpus {
+		r := <-rchan
+		verb(1, "result: %v", r)
+		if !r.supported {
+			continue
+		}
+		if _, ok := visited[r.cpu]; ok {
+			continue
+		}
+		visited[r.cpu] = true
+		results = append(results, r)
+	}
+
+	// Sort, then write to output
+	fmt.Fprintf(bw, "// triple: %s\n", triple)
+	fmt.Fprintf(bw, "static const CpuAttrs attrs%d[] = {\n", idx)
+	bw.WriteString("  // first entry is default cpu\n")
+	sort.Sort(ByCpu(results))
+	for i := 0; i < len(results); i++ {
+		r := results[i]
+		fmt.Fprintf(bw, "  { \"%s\", \"%s\" },\n", r.cpu, r.attrs)
+	}
+	bw.WriteString("  { \"\", \"\" } // sentinel\n")
+	bw.WriteString("};\n\n")
+}
+
+// Runs llc to determine default triple value.
+
+func collectDefaultTriple() string {
+	// Run llc to collect default triple
+	llcargs := []string{"--version"}
+	cmd := exec.Command("llc", llcargs...)
+	output, err := cmd.CombinedOutput()
+	verb(3, "llc output is: %s\n", string(output))
+	if err != nil {
+		fatal("llc --version failed")
+	}
+
+	rx := regexp.MustCompile(`^\s*Default target:\s+(\S+)\s*$`)
+	scanner := bufio.NewScanner(strings.NewReader(string(output)))
+	scanner.Split(bufio.ScanLines)
+	for scanner.Scan() {
+		verb(3, "llc line is: %s", scanner.Text())
+		asl := rx.FindSubmatch(scanner.Bytes())
+		if len(asl) == 2 {
+			return string(asl[1])
+		}
+	}
+
+	fatal("parsing of llc --version output failed")
+	return ""
+}
+
+func genCPUs(triple string) []string {
+
+	// If -cpu XXX then just use that.
+	if *cpuflag != "" {
+		return strings.Split(*cpuflag, ",")
+	}
+
+	// Alternatively, look at the output of "llc -mcpu=help" (running
+	// clang with "-march=IllegalBadVal" also has similar effects, but
+	// doesn't allow you to set the triple currently).
+
+	tgtopt := []string{"-mcpu=help", fmt.Sprintf("-mtriple=%s", triple)}
+	cmd := exec.Command("llc", tgtopt...)
+	output, cerr := cmd.CombinedOutput()
+	if cerr != nil {
+		warn("llc run failed: %s", output)
+		fatal("err = %v", cerr)
+	}
+	verb(3, "llc output is: %s\n", string(output))
+
+	// Parse the output
+	resultcpus := []string{""}
+	rw := regexp.MustCompile(`^\s*$`)
+	r1 := regexp.MustCompile(`^Available (\S+) for this target:\s*$`)
+	r2 := regexp.MustCompile(`^\s*(\S+)\s+\-\s\S.*$`)
+	rtx := regexp.MustCompile(`^Use \+feature.*$`)
+	rty := regexp.MustCompile(`^For example.*$`)
+	scanner := bufio.NewScanner(strings.NewReader(string(output)))
+	scanner.Split(bufio.ScanLines)
+	which := ""
+	for scanner.Scan() {
+		verb(3, "llc line is: %s", scanner.Text())
+		lineb := scanner.Bytes()
+		if rw.Find(lineb) != nil || rtx.Find(lineb) != nil ||
+			rty.Find(lineb) != nil {
+			continue
+		}
+		asl := r1.FindSubmatch(lineb)
+		if len(asl) == 2 {
+			which = string(asl[1])
+			continue
+		}
+		bsl := r2.FindSubmatch(lineb)
+		if len(bsl) == 2 {
+			if which == "CPUs" {
+				cpu := string(bsl[1])
+				resultcpus = append(resultcpus, cpu)
+			}
+			continue
+		}
+		warn("unmatched lined in llc output: %s", string(lineb))
+	}
+	if scanner.Err() != nil {
+		fatal("error scanning llc output: %v", scanner.Err())
+	}
+
+	return resultcpus
+}
+
+const pream1 = `// DO NOT EDIT: this file auto-generated by the following command:
+//
+`
+
+const pream2 = `
+typedef struct {
+  const char *cpu;
+  const char *attrs;
+} CpuAttrs;
+
+typedef struct {
+  const char *triple;
+  const CpuAttrs *cpuattrs;
+} TripleCpus;
+
+`
+
+func prolog(bw *bufio.Writer) {
+	bw.WriteString(pream1)
+	bw.WriteString("//   ")
+	for _, arg := range os.Args {
+		bw.WriteString(" ")
+		bw.WriteString(arg)
+	}
+	bw.WriteString("\n//\n")
+	bw.WriteString("// in combination with clang:\n//\n")
+	cmd := exec.Command("clang", "--version")
+	output, cerr := cmd.CombinedOutput()
+	if cerr != nil {
+		warn("clang run failed: %s", output)
+		fatal("err = %v", cerr)
+	}
+	sl := strings.Split(string(output), "\n")
+	bw.WriteString("//  ")
+	bw.WriteString(sl[0])
+	bw.WriteString("\n//\n")
+	bw.WriteString(pream2)
+}
+
+func epilog(bw *bufio.Writer, triples []string) {
+	bw.WriteString("const TripleCpus triples[] = {\n")
+	for k, t := range triples {
+		bw.WriteString(fmt.Sprintf("  { \"%s\", &attrs%d[0] },\n", t, k))
+	}
+	bw.WriteString("  { \"\", nullptr } // sentinel\n")
+	bw.WriteString("};\n")
+}
+
+func perform() {
+
+	// Create tempdir
+	dir, err := ioutil.TempDir("", "CaptureFcnAttrsTempDir")
+	if err != nil {
+		fatal("ioutil.TempDir failed, err=%v", err)
+	}
+	if *noclflag {
+		defer func() { fmt.Printf("preserving temp dir %s\n", dir) }()
+	} else {
+		defer os.RemoveAll(dir)
+	}
+
+	// Emit tempfile
+	tf := filepath.Join(dir, "file.c")
+	verb(1, "temp file is %s", tf)
+	if err := ioutil.WriteFile(tf, []byte(prog), 0666); err != nil {
+		fatal("ioutil.WriteFile failed, err=%v", err)
+	}
+
+	// Open output file
+	var outfile = os.Stdout
+	if len(*outfileflag) > 0 {
+		verb(1, "opening %s", *outfileflag)
+		outfile, err = os.OpenFile(*outfileflag,
+			os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666)
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+
+	defaultTriple = collectDefaultTriple()
+	triples := strings.Split(*triplesflag, ",")
+	if len(triples) == 0 {
+		triples = append(triples, defaultTriple)
+	}
+	bw := bufio.NewWriter(outfile)
+	prolog(bw)
+	for k, trip := range triples {
+
+		// CPU selection (either from option or via clang/llc)
+		cpus := genCPUs(trip)
+
+		// Enumerate attributes for the specified CPUs
+		enumerateAttributes(trip, dir, cpus, bw, tf, k)
+	}
+	epilog(bw, triples)
+	if err := bw.Flush(); err != nil {
+		fatal("error writing output: %v", err)
+	}
+	if len(*outfileflag) > 0 {
+		if err := outfile.Close(); err != nil {
+			fatal("error closing output file %s: %v", *outfileflag, err)
+		}
+	}
+}
+
+func main() {
+	log.SetFlags(0)
+	log.SetPrefix("capture-fcn-attributes: ")
+	flag.Parse()
+	verb(1, "in main")
+	if flag.NArg() != 0 {
+		usage("please run without arguments")
+	}
+	perform()
+	verb(1, "leaving main")
+	os.Exit(exitst)
+}