1 //===-- InlineAsm.cpp - Implement the InlineAsm class ---------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the InlineAsm class.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/IR/InlineAsm.h"
15 #include "ConstantsContext.h"
16 #include "LLVMContextImpl.h"
17 #include "llvm/IR/DerivedTypes.h"
18 #include <algorithm>
19 #include <cctype>
20 using namespace llvm;
21 
22 // Implement the first virtual method in this class in this file so the
23 // InlineAsm vtable is emitted here.
~InlineAsm()24 InlineAsm::~InlineAsm() {
25 }
26 
get(FunctionType * FTy,StringRef AsmString,StringRef Constraints,bool hasSideEffects,bool isAlignStack,AsmDialect asmDialect)27 InlineAsm *InlineAsm::get(FunctionType *FTy, StringRef AsmString,
28                           StringRef Constraints, bool hasSideEffects,
29                           bool isAlignStack, AsmDialect asmDialect) {
30   InlineAsmKeyType Key(AsmString, Constraints, FTy, hasSideEffects,
31                        isAlignStack, asmDialect);
32   LLVMContextImpl *pImpl = FTy->getContext().pImpl;
33   return pImpl->InlineAsms.getOrCreate(PointerType::getUnqual(FTy), Key);
34 }
35 
InlineAsm(FunctionType * FTy,const std::string & asmString,const std::string & constraints,bool hasSideEffects,bool isAlignStack,AsmDialect asmDialect)36 InlineAsm::InlineAsm(FunctionType *FTy, const std::string &asmString,
37                      const std::string &constraints, bool hasSideEffects,
38                      bool isAlignStack, AsmDialect asmDialect)
39     : Value(PointerType::getUnqual(FTy), Value::InlineAsmVal),
40       AsmString(asmString), Constraints(constraints), FTy(FTy),
41       HasSideEffects(hasSideEffects), IsAlignStack(isAlignStack),
42       Dialect(asmDialect) {
43 
44   // Do various checks on the constraint string and type.
45   assert(Verify(getFunctionType(), constraints) &&
46          "Function type not legal for constraints!");
47 }
48 
destroyConstant()49 void InlineAsm::destroyConstant() {
50   getType()->getContext().pImpl->InlineAsms.remove(this);
51   delete this;
52 }
53 
getFunctionType() const54 FunctionType *InlineAsm::getFunctionType() const {
55   return FTy;
56 }
57 
58 ///Default constructor.
ConstraintInfo()59 InlineAsm::ConstraintInfo::ConstraintInfo() :
60   Type(isInput), isEarlyClobber(false),
61   MatchingInput(-1), isCommutative(false),
62   isIndirect(false), isMultipleAlternative(false),
63   currentAlternativeIndex(0) {
64 }
65 
66 /// Parse - Analyze the specified string (e.g. "==&{eax}") and fill in the
67 /// fields in this structure.  If the constraint string is not understood,
68 /// return true, otherwise return false.
Parse(StringRef Str,InlineAsm::ConstraintInfoVector & ConstraintsSoFar)69 bool InlineAsm::ConstraintInfo::Parse(StringRef Str,
70                      InlineAsm::ConstraintInfoVector &ConstraintsSoFar) {
71   StringRef::iterator I = Str.begin(), E = Str.end();
72   unsigned multipleAlternativeCount = Str.count('|') + 1;
73   unsigned multipleAlternativeIndex = 0;
74   ConstraintCodeVector *pCodes = &Codes;
75 
76   // Initialize
77   isMultipleAlternative = multipleAlternativeCount > 1;
78   if (isMultipleAlternative) {
79     multipleAlternatives.resize(multipleAlternativeCount);
80     pCodes = &multipleAlternatives[0].Codes;
81   }
82   Type = isInput;
83   isEarlyClobber = false;
84   MatchingInput = -1;
85   isCommutative = false;
86   isIndirect = false;
87   currentAlternativeIndex = 0;
88 
89   // Parse prefixes.
90   if (*I == '~') {
91     Type = isClobber;
92     ++I;
93 
94     // '{' must immediately follow '~'.
95     if (I != E && *I != '{')
96       return true;
97   } else if (*I == '=') {
98     ++I;
99     Type = isOutput;
100   }
101 
102   if (*I == '*') {
103     isIndirect = true;
104     ++I;
105   }
106 
107   if (I == E) return true;  // Just a prefix, like "==" or "~".
108 
109   // Parse the modifiers.
110   bool DoneWithModifiers = false;
111   while (!DoneWithModifiers) {
112     switch (*I) {
113     default:
114       DoneWithModifiers = true;
115       break;
116     case '&':     // Early clobber.
117       if (Type != isOutput ||      // Cannot early clobber anything but output.
118           isEarlyClobber)          // Reject &&&&&&
119         return true;
120       isEarlyClobber = true;
121       break;
122     case '%':     // Commutative.
123       if (Type == isClobber ||     // Cannot commute clobbers.
124           isCommutative)           // Reject %%%%%
125         return true;
126       isCommutative = true;
127       break;
128     case '#':     // Comment.
129     case '*':     // Register preferencing.
130       return true;     // Not supported.
131     }
132 
133     if (!DoneWithModifiers) {
134       ++I;
135       if (I == E) return true;   // Just prefixes and modifiers!
136     }
137   }
138 
139   // Parse the various constraints.
140   while (I != E) {
141     if (*I == '{') {   // Physical register reference.
142       // Find the end of the register name.
143       StringRef::iterator ConstraintEnd = std::find(I+1, E, '}');
144       if (ConstraintEnd == E) return true;  // "{foo"
145       pCodes->push_back(std::string(I, ConstraintEnd+1));
146       I = ConstraintEnd+1;
147     } else if (isdigit(static_cast<unsigned char>(*I))) { // Matching Constraint
148       // Maximal munch numbers.
149       StringRef::iterator NumStart = I;
150       while (I != E && isdigit(static_cast<unsigned char>(*I)))
151         ++I;
152       pCodes->push_back(std::string(NumStart, I));
153       unsigned N = atoi(pCodes->back().c_str());
154       // Check that this is a valid matching constraint!
155       if (N >= ConstraintsSoFar.size() || ConstraintsSoFar[N].Type != isOutput||
156           Type != isInput)
157         return true;  // Invalid constraint number.
158 
159       // If Operand N already has a matching input, reject this.  An output
160       // can't be constrained to the same value as multiple inputs.
161       if (isMultipleAlternative) {
162         if (multipleAlternativeIndex >=
163             ConstraintsSoFar[N].multipleAlternatives.size())
164           return true;
165         InlineAsm::SubConstraintInfo &scInfo =
166           ConstraintsSoFar[N].multipleAlternatives[multipleAlternativeIndex];
167         if (scInfo.MatchingInput != -1)
168           return true;
169         // Note that operand #n has a matching input.
170         scInfo.MatchingInput = ConstraintsSoFar.size();
171       } else {
172         if (ConstraintsSoFar[N].hasMatchingInput() &&
173             (size_t)ConstraintsSoFar[N].MatchingInput !=
174                 ConstraintsSoFar.size())
175           return true;
176         // Note that operand #n has a matching input.
177         ConstraintsSoFar[N].MatchingInput = ConstraintsSoFar.size();
178         }
179     } else if (*I == '|') {
180       multipleAlternativeIndex++;
181       pCodes = &multipleAlternatives[multipleAlternativeIndex].Codes;
182       ++I;
183     } else if (*I == '^') {
184       // Multi-letter constraint
185       // FIXME: For now assuming these are 2-character constraints.
186       pCodes->push_back(std::string(I+1, I+3));
187       I += 3;
188     } else {
189       // Single letter constraint.
190       pCodes->push_back(std::string(I, I+1));
191       ++I;
192     }
193   }
194 
195   return false;
196 }
197 
198 /// selectAlternative - Point this constraint to the alternative constraint
199 /// indicated by the index.
selectAlternative(unsigned index)200 void InlineAsm::ConstraintInfo::selectAlternative(unsigned index) {
201   if (index < multipleAlternatives.size()) {
202     currentAlternativeIndex = index;
203     InlineAsm::SubConstraintInfo &scInfo =
204       multipleAlternatives[currentAlternativeIndex];
205     MatchingInput = scInfo.MatchingInput;
206     Codes = scInfo.Codes;
207   }
208 }
209 
210 InlineAsm::ConstraintInfoVector
ParseConstraints(StringRef Constraints)211 InlineAsm::ParseConstraints(StringRef Constraints) {
212   ConstraintInfoVector Result;
213 
214   // Scan the constraints string.
215   for (StringRef::iterator I = Constraints.begin(),
216          E = Constraints.end(); I != E; ) {
217     ConstraintInfo Info;
218 
219     // Find the end of this constraint.
220     StringRef::iterator ConstraintEnd = std::find(I, E, ',');
221 
222     if (ConstraintEnd == I ||  // Empty constraint like ",,"
223         Info.Parse(StringRef(I, ConstraintEnd-I), Result)) {
224       Result.clear();          // Erroneous constraint?
225       break;
226     }
227 
228     Result.push_back(Info);
229 
230     // ConstraintEnd may be either the next comma or the end of the string.  In
231     // the former case, we skip the comma.
232     I = ConstraintEnd;
233     if (I != E) {
234       ++I;
235       if (I == E) {
236         Result.clear();
237         break;
238       } // don't allow "xyz,"
239     }
240   }
241 
242   return Result;
243 }
244 
245 /// Verify - Verify that the specified constraint string is reasonable for the
246 /// specified function type, and otherwise validate the constraint string.
Verify(FunctionType * Ty,StringRef ConstStr)247 bool InlineAsm::Verify(FunctionType *Ty, StringRef ConstStr) {
248   if (Ty->isVarArg()) return false;
249 
250   ConstraintInfoVector Constraints = ParseConstraints(ConstStr);
251 
252   // Error parsing constraints.
253   if (Constraints.empty() && !ConstStr.empty()) return false;
254 
255   unsigned NumOutputs = 0, NumInputs = 0, NumClobbers = 0;
256   unsigned NumIndirect = 0;
257 
258   for (unsigned i = 0, e = Constraints.size(); i != e; ++i) {
259     switch (Constraints[i].Type) {
260     case InlineAsm::isOutput:
261       if ((NumInputs-NumIndirect) != 0 || NumClobbers != 0)
262         return false;  // outputs before inputs and clobbers.
263       if (!Constraints[i].isIndirect) {
264         ++NumOutputs;
265         break;
266       }
267       ++NumIndirect;
268       // FALLTHROUGH for Indirect Outputs.
269     case InlineAsm::isInput:
270       if (NumClobbers) return false;               // inputs before clobbers.
271       ++NumInputs;
272       break;
273     case InlineAsm::isClobber:
274       ++NumClobbers;
275       break;
276     }
277   }
278 
279   switch (NumOutputs) {
280   case 0:
281     if (!Ty->getReturnType()->isVoidTy()) return false;
282     break;
283   case 1:
284     if (Ty->getReturnType()->isStructTy()) return false;
285     break;
286   default:
287     StructType *STy = dyn_cast<StructType>(Ty->getReturnType());
288     if (!STy || STy->getNumElements() != NumOutputs)
289       return false;
290     break;
291   }
292 
293   if (Ty->getNumParams() != NumInputs) return false;
294   return true;
295 }
296