tools/llvmc/src/Hooks.cpp

   1 #include "llvm/ADT/StringMap.h"
   2
   3 #include <string>
   4 #include <vector>
   5
   6 namespace hooks {
   7
   8 /// NUM_KEYS - Calculate the size of a const char* array.
   9 #define NUM_KEYS(Keys) sizeof(Keys) / sizeof(const char*)
  10
  11 // See http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
  12 inline unsigned NextHighestPowerOf2 (unsigned i) {
  13   i |= i >> 1;
  14   i |= i >> 2;
  15   i |= i >> 4;
  16   i |= i >> 8;
  17   i |= i >> 16;
  18   i++;
  19   return i;
  20 }
  21
  22 typedef std::vector<std::string> StrVec;
  23 typedef llvm::StringMap<const char*> ArgMap;
  24
  25
  26 /// AddPlusOrMinus - Convert 'no-foo' to '-foo' and 'foo' to '+foo'.
  27 void AddPlusOrMinus (const std::string& Arg, std::string& out) {
  28   if (Arg.find("no-") == 0 && Arg[3] != 0) {
  29     out += '-';
  30     out += Arg.c_str() + 3;
  31   }
  32   else {
  33     out += '+';
  34     out += Arg;
  35   }
  36 }
  37
  38 // -march values that need to be special-cased.
  39 const char* MArchKeysARM[] = { "armv4t", "armv5t", "armv5te", "armv6",
  40                                "armv6-m", "armv6t2", "armv7-a", "armv7-m" };
  41 const char* MArchValuesARM[] = { "v4t", "v5t", "v5te", "v6", "v6m", "v6t2",
  42                                  "v7a", "v7m" };
  43 const unsigned MArchNumKeysARM = NUM_KEYS(MArchKeysARM);
  44 const unsigned MArchMapSize = NextHighestPowerOf2(MArchNumKeysARM);
  45
  46 // -march values that should be forwarded as -mcpu
  47 const char* MArchMCpuKeysARM[] = { "iwmmxt", "ep9312" };
  48 const char* MArchMCpuValuesARM[] = { "iwmmxt", "ep9312"};
  49 const unsigned MArchMCpuNumKeysARM = NUM_KEYS(MArchMCpuKeysARM);
  50 const unsigned MArchMCpuMapSize = NextHighestPowerOf2(MArchMCpuNumKeysARM);
  51
  52
  53 void FillInArgMap(ArgMap& Args, const char* Keys[],
  54                   const char* Values[], unsigned NumKeys)
  55 {
  56   for (unsigned i = 0; i < NumKeys; ++i) {
  57     // Explicit cast to StringRef here is necessary to pick up the right
  58     // overload.
  59     Args.GetOrCreateValue(llvm::StringRef(Keys[i]), Values[i]);
  60   }
  61 }
  62
  63 /// ConvertMArchToMAttr - Convert -march from the gcc dialect to
  64 /// something llc can understand.
  65 std::string ConvertMArchToMAttr(const StrVec& Opts) {
  66   static ArgMap MArchMap(MArchMapSize);
  67   static ArgMap MArchMCpuMap(MArchMapSize);
  68   static bool StaticDataInitialized = false;
  69
  70   if (!StaticDataInitialized) {
  71     FillInArgMap(MArchMap, MArchKeysARM, MArchValuesARM, MArchNumKeysARM);
  72     FillInArgMap(MArchMCpuMap, MArchMCpuKeysARM,
  73                  MArchMCpuValuesARM, MArchMCpuNumKeysARM);
  74     StaticDataInitialized = true;
  75   }
  76
  77   std::string mattr("-mattr=");
  78   std::string mcpu("-mcpu=");
  79   bool mattrTouched = false;
  80   bool mcpuTouched = false;
  81   bool firstIter = true;
  82
  83   for (StrVec::const_iterator B = Opts.begin(), E = Opts.end(); B!=E; ++B) {
  84     const std::string& Arg = *B;
  85
  86     if (firstIter)
  87       firstIter = false;
  88     else
  89       mattr += ",";
  90
  91     // Check if the argument is a special case.
  92     {
  93       ArgMap::const_iterator I = MArchMap.find(Arg);
  94
  95       if (I != MArchMap.end()) {
  96         mattr += '+';
  97         mattr += I->getValue();
  98         continue;
  99       }
 100     }
 101
 102     // Check if the argument should be forwarded to -mcpu instead of -mattr.
 103     {
 104       ArgMap::const_iterator I = MArchMCpuMap.find(Arg);
 105
 106       if (I != MArchMCpuMap.end()) {
 107         mcpuTouched = true;
 108         mcpu += I->getValue();
 109         continue;
 110       }
 111     }
 112
 113     AddPlusOrMinus(Arg, mattr);
 114   }
 115
 116   std::string out;
 117   if (mattrTouched)
 118     out += mattr;
 119   if (mcpuTouched)
 120     out += (mattrTouched ? " " : "") + mcpu;
 121
 122   return out;
 123 }
 124
 125 // -mcpu values that need to be special-cased.
 126 const char* MCpuKeysPPC[] = { "G3", "G4", "G5", "powerpc", "powerpc64"};
 127 const char* MCpuValuesPPC[] = { "g3", "g4", "g5", "ppc", "ppc64"};
 128 const unsigned MCpuNumKeysPPC = NUM_KEYS(MCpuKeysPPC);
 129 const unsigned MCpuMapSize = NextHighestPowerOf2(MCpuNumKeysPPC);
 130
 131 /// ConvertMCpu - Convert -mcpu value from the gcc to the llc dialect.
 132 std::string ConvertMCpu(const char* Val) {
 133   static ArgMap MCpuMap(MCpuMapSize);
 134   static bool StaticDataInitialized = false;
 135
 136   if (!StaticDataInitialized) {
 137     FillInArgMap(MCpuMap, MCpuKeysPPC, MCpuValuesPPC, MCpuNumKeysPPC);
 138     StaticDataInitialized = true;
 139   }
 140
 141   std::string ret = "-mcpu=";
 142   ArgMap::const_iterator I = MCpuMap.find(Val);
 143   if (I != MCpuMap.end()) {
 144     return ret + I->getValue();
 145   }
 146   return ret + Val;
 147 }
 148
 149 // -mfpu values that need to be special-cased.
 150 const char* MFpuKeysARM[] = { "vfp", "vfpv3",
 151                               "vfpv3-fp16", "vfpv3-d16", "vfpv3-d16-fp16",
 152                               "neon", "neon-fp16" };
 153 const char* MFpuValuesARM[] = { "vfp2", "vfp3",
 154                                 "+vfp3,+fp16", "+vfp3,+d16", "+vfp3,+d16,+fp16",
 155                                 "+neon", "+neon,+neonfp" };
 156 const unsigned MFpuNumKeysARM = NUM_KEYS(MFpuKeysARM);
 157 const unsigned MFpuMapSize = NextHighestPowerOf2(MFpuNumKeysARM);
 158
 159 /// ConvertMFpu - Convert -mfpu value from the gcc to the llc dialect.
 160 std::string ConvertMFpu(const char* Val) {
 161   static ArgMap MFpuMap(MFpuMapSize);
 162   static bool StaticDataInitialized = false;
 163
 164   if (!StaticDataInitialized) {
 165     FillInArgMap(MFpuMap, MFpuKeysARM, MFpuValuesARM, MFpuNumKeysARM);
 166     StaticDataInitialized = true;
 167   }
 168
 169   std::string ret = "-mattr=";
 170   ArgMap::const_iterator I = MFpuMap.find(Val);
 171   if (I != MFpuMap.end()) {
 172     return ret + I->getValue();
 173   }
 174   return ret + '+' + Val;
 175 }
 176
 177 /// ConvertToMAttr - Convert '-mfoo' and '-mno-bar' to '-mattr=+foo,-bar'.
 178 std::string ConvertToMAttr(const StrVec& Opts) {
 179   std::string out("-mattr=");
 180   bool firstIter = true;
 181
 182   for (StrVec::const_iterator B = Opts.begin(), E = Opts.end(); B!=E; ++B) {
 183     const std::string& Arg = *B;
 184
 185     if (firstIter)
 186       firstIter = false;
 187     else
 188       out += ",";
 189
 190     AddPlusOrMinus(Arg, out);
 191   }
 192
 193   return out;
 194 }
 195
 196 }