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