Thumb2 assembly parsing and encoding for UHSUB16/UHSUB8.

[oota-llvm.git] / tools / llvmc / src / Hooks.cpp

diff --git a/tools/llvmc/src/Hooks.cpp b/tools/llvmc/src/Hooks.cpp
index 8755b1a3fb8e41f160c34859a64fbc092ef22082..ddad08a1b4ca5be9394efc0dc7b4d1bd00a6fcc2 100644 (file)
--- a/tools/llvmc/src/Hooks.cpp
+++ b/tools/llvmc/src/Hooks.cpp
@@ -10,58 +10,29 @@ namespace hooks {
 
 // See http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
 inline unsigned NextHighestPowerOf2 (unsigned i) {
+  --i;
   i |= i >> 1;
   i |= i >> 2;
   i |= i >> 4;
   i |= i >> 8;
   i |= i >> 16;
-  i++;
+  ++i;
   return i;
 }
 
 typedef std::vector<std::string> StrVec;
 typedef llvm::StringMap<const char*> ArgMap;
 
-/// ConvertToMAttrImpl - Common implementation of ConvertMArchToMAttr and
-/// ConvertToMAttr. The optional Args parameter contains information about how
-/// to transform special-cased values (for example, '-march=armv6' must be
-/// forwarded as '-mattr=+v6').
-std::string ConvertToMAttrImpl(const StrVec& Opts, const ArgMap* Args = 0) {
-  std::string out("-mattr=");
-  bool firstIter = true;
-
-  for (StrVec::const_iterator B = Opts.begin(), E = Opts.end(); B!=E; ++B) {
-    const std::string& Arg = *B;
-
-    if (firstIter)
-      firstIter = false;
-    else
-      out += ",";
-
-    // Check if the argument is a special case.
-    if (Args != 0) {
-      ArgMap::const_iterator I = Args->find(Arg);
-
-      if (I != Args->end()) {
-        out += '+';
-        out += I->getValue();
-        continue;
-      }
-    }
-
-    // Convert 'no-foo' to '-foo'.
-    if (Arg.find("no-") == 0 && Arg[3] != 0) {
-      out += '-';
-      out += Arg.c_str() + 3;
-    }
-    // Convert 'foo' to '+foo'.
-    else {
-      out += '+';
-      out += Arg;
-    }
+/// AddPlusOrMinus - Convert 'no-foo' to '-foo' and 'foo' to '+foo'.
+void AddPlusOrMinus (const std::string& Arg, std::string& out) {
+  if (Arg.find("no-") == 0 && Arg[3] != 0) {
+    out += '-';
+    out += Arg.c_str() + 3;
+  }
+  else {
+    out += '+';
+    out += Arg;
   }
-
-  return out;
 }
 
 // -march values that need to be special-cased.
@@ -72,6 +43,12 @@ const char* MArchValuesARM[] = { "v4t", "v5t", "v5te", "v6", "v6m", "v6t2",
 const unsigned MArchNumKeysARM = NUM_KEYS(MArchKeysARM);
 const unsigned MArchMapSize = NextHighestPowerOf2(MArchNumKeysARM);
 
+// -march values that should be forwarded as -mcpu
+const char* MArchMCpuKeysARM[] = { "iwmmxt", "ep9312" };
+const char* MArchMCpuValuesARM[] = { "iwmmxt", "ep9312"};
+const unsigned MArchMCpuNumKeysARM = NUM_KEYS(MArchMCpuKeysARM);
+
+
 void FillInArgMap(ArgMap& Args, const char* Keys[],
                   const char* Values[], unsigned NumKeys)
 {
@@ -86,14 +63,60 @@ void FillInArgMap(ArgMap& Args, const char* Keys[],
 /// something llc can understand.
 std::string ConvertMArchToMAttr(const StrVec& Opts) {
   static ArgMap MArchMap(MArchMapSize);
+  static ArgMap MArchMCpuMap(MArchMapSize);
   static bool StaticDataInitialized = false;
 
   if (!StaticDataInitialized) {
     FillInArgMap(MArchMap, MArchKeysARM, MArchValuesARM, MArchNumKeysARM);
+    FillInArgMap(MArchMCpuMap, MArchMCpuKeysARM,
+                 MArchMCpuValuesARM, MArchMCpuNumKeysARM);
     StaticDataInitialized = true;
   }
 
-  return ConvertToMAttrImpl(Opts, &MArchMap);
+  std::string mattr("-mattr=");
+  std::string mcpu("-mcpu=");
+  bool mattrTouched = false;
+  bool mcpuTouched = false;
+
+  for (StrVec::const_iterator B = Opts.begin(), E = Opts.end(); B!=E; ++B) {
+    const std::string& Arg = *B;
+
+    // Check if the argument should be forwarded to -mcpu instead of -mattr.
+    {
+      ArgMap::const_iterator I = MArchMCpuMap.find(Arg);
+
+      if (I != MArchMCpuMap.end()) {
+        mcpuTouched = true;
+        mcpu += I->getValue();
+        continue;
+      }
+    }
+
+    if (mattrTouched)
+      mattr += ",";
+
+    // Check if the argument is a special case.
+    {
+      ArgMap::const_iterator I = MArchMap.find(Arg);
+
+      if (I != MArchMap.end()) {
+        mattrTouched = true;
+        mattr += '+';
+        mattr += I->getValue();
+        continue;
+      }
+    }
+
+    AddPlusOrMinus(Arg, mattr);
+  }
+
+  std::string out;
+  if (mattrTouched)
+    out += mattr;
+  if (mcpuTouched)
+    out += (mattrTouched ? " " : "") + mcpu;
+
+  return out;
 }
 
 // -mcpu values that need to be special-cased.
@@ -150,7 +173,21 @@ std::string ConvertMFpu(const char* Val) {
 
 /// ConvertToMAttr - Convert '-mfoo' and '-mno-bar' to '-mattr=+foo,-bar'.
 std::string ConvertToMAttr(const StrVec& Opts) {
-  return ConvertToMAttrImpl(Opts);
+  std::string out("-mattr=");
+  bool firstIter = true;
+
+  for (StrVec::const_iterator B = Opts.begin(), E = Opts.end(); B!=E; ++B) {
+    const std::string& Arg = *B;
+
+    if (firstIter)
+      firstIter = false;
+    else
+      out += ",";
+
+    AddPlusOrMinus(Arg, out);
+  }
+
+  return out;
 }
 
 }