1 //===- InlineAsm.cpp - Implement the InlineAsm class ----------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the InlineAsm class.
12 //===----------------------------------------------------------------------===//
14 #include "llvm/IR/InlineAsm.h"
15 #include "ConstantsContext.h"
16 #include "LLVMContextImpl.h"
17 #include "llvm/ADT/StringRef.h"
18 #include "llvm/IR/DerivedTypes.h"
19 #include "llvm/IR/LLVMContext.h"
20 #include "llvm/IR/Value.h"
21 #include "llvm/Support/Casting.h"
22 #include "llvm/Support/Compiler.h"
31 InlineAsm::InlineAsm(FunctionType *FTy, const std::string &asmString,
32 const std::string &constraints, bool hasSideEffects,
33 bool isAlignStack, AsmDialect asmDialect)
34 : Value(PointerType::getUnqual(FTy), Value::InlineAsmVal),
35 AsmString(asmString), Constraints(constraints), FTy(FTy),
36 HasSideEffects(hasSideEffects), IsAlignStack(isAlignStack),
38 // Do various checks on the constraint string and type.
39 assert(Verify(getFunctionType(), constraints) &&
40 "Function type not legal for constraints!");
43 InlineAsm *InlineAsm::get(FunctionType *FTy, StringRef AsmString,
44 StringRef Constraints, bool hasSideEffects,
45 bool isAlignStack, AsmDialect asmDialect) {
46 InlineAsmKeyType Key(AsmString, Constraints, FTy, hasSideEffects,
47 isAlignStack, asmDialect);
48 LLVMContextImpl *pImpl = FTy->getContext().pImpl;
49 return pImpl->InlineAsms.getOrCreate(PointerType::getUnqual(FTy), Key);
52 void InlineAsm::destroyConstant() {
53 getType()->getContext().pImpl->InlineAsms.remove(this);
57 FunctionType *InlineAsm::getFunctionType() const {
61 /// Parse - Analyze the specified string (e.g. "==&{eax}") and fill in the
62 /// fields in this structure. If the constraint string is not understood,
63 /// return true, otherwise return false.
64 bool InlineAsm::ConstraintInfo::Parse(StringRef Str,
65 InlineAsm::ConstraintInfoVector &ConstraintsSoFar) {
66 StringRef::iterator I = Str.begin(), E = Str.end();
67 unsigned multipleAlternativeCount = Str.count('|') + 1;
68 unsigned multipleAlternativeIndex = 0;
69 ConstraintCodeVector *pCodes = &Codes;
72 isMultipleAlternative = multipleAlternativeCount > 1;
73 if (isMultipleAlternative) {
74 multipleAlternatives.resize(multipleAlternativeCount);
75 pCodes = &multipleAlternatives[0].Codes;
78 isEarlyClobber = false;
80 isCommutative = false;
82 currentAlternativeIndex = 0;
89 // '{' must immediately follow '~'.
90 if (I != E && *I != '{')
92 } else if (*I == '=') {
102 if (I == E) return true; // Just a prefix, like "==" or "~".
104 // Parse the modifiers.
105 bool DoneWithModifiers = false;
106 while (!DoneWithModifiers) {
109 DoneWithModifiers = true;
111 case '&': // Early clobber.
112 if (Type != isOutput || // Cannot early clobber anything but output.
113 isEarlyClobber) // Reject &&&&&&
115 isEarlyClobber = true;
117 case '%': // Commutative.
118 if (Type == isClobber || // Cannot commute clobbers.
119 isCommutative) // Reject %%%%%
121 isCommutative = true;
123 case '#': // Comment.
124 case '*': // Register preferencing.
125 return true; // Not supported.
128 if (!DoneWithModifiers) {
130 if (I == E) return true; // Just prefixes and modifiers!
134 // Parse the various constraints.
136 if (*I == '{') { // Physical register reference.
137 // Find the end of the register name.
138 StringRef::iterator ConstraintEnd = std::find(I+1, E, '}');
139 if (ConstraintEnd == E) return true; // "{foo"
140 pCodes->push_back(StringRef(I, ConstraintEnd+1 - I));
142 } else if (isdigit(static_cast<unsigned char>(*I))) { // Matching Constraint
143 // Maximal munch numbers.
144 StringRef::iterator NumStart = I;
145 while (I != E && isdigit(static_cast<unsigned char>(*I)))
147 pCodes->push_back(StringRef(NumStart, I - NumStart));
148 unsigned N = atoi(pCodes->back().c_str());
149 // Check that this is a valid matching constraint!
150 if (N >= ConstraintsSoFar.size() || ConstraintsSoFar[N].Type != isOutput||
152 return true; // Invalid constraint number.
154 // If Operand N already has a matching input, reject this. An output
155 // can't be constrained to the same value as multiple inputs.
156 if (isMultipleAlternative) {
157 if (multipleAlternativeIndex >=
158 ConstraintsSoFar[N].multipleAlternatives.size())
160 InlineAsm::SubConstraintInfo &scInfo =
161 ConstraintsSoFar[N].multipleAlternatives[multipleAlternativeIndex];
162 if (scInfo.MatchingInput != -1)
164 // Note that operand #n has a matching input.
165 scInfo.MatchingInput = ConstraintsSoFar.size();
167 if (ConstraintsSoFar[N].hasMatchingInput() &&
168 (size_t)ConstraintsSoFar[N].MatchingInput !=
169 ConstraintsSoFar.size())
171 // Note that operand #n has a matching input.
172 ConstraintsSoFar[N].MatchingInput = ConstraintsSoFar.size();
174 } else if (*I == '|') {
175 multipleAlternativeIndex++;
176 pCodes = &multipleAlternatives[multipleAlternativeIndex].Codes;
178 } else if (*I == '^') {
179 // Multi-letter constraint
180 // FIXME: For now assuming these are 2-character constraints.
181 pCodes->push_back(StringRef(I+1, 2));
184 // Single letter constraint.
185 pCodes->push_back(StringRef(I, 1));
193 /// selectAlternative - Point this constraint to the alternative constraint
194 /// indicated by the index.
195 void InlineAsm::ConstraintInfo::selectAlternative(unsigned index) {
196 if (index < multipleAlternatives.size()) {
197 currentAlternativeIndex = index;
198 InlineAsm::SubConstraintInfo &scInfo =
199 multipleAlternatives[currentAlternativeIndex];
200 MatchingInput = scInfo.MatchingInput;
201 Codes = scInfo.Codes;
205 InlineAsm::ConstraintInfoVector
206 InlineAsm::ParseConstraints(StringRef Constraints) {
207 ConstraintInfoVector Result;
209 // Scan the constraints string.
210 for (StringRef::iterator I = Constraints.begin(),
211 E = Constraints.end(); I != E; ) {
214 // Find the end of this constraint.
215 StringRef::iterator ConstraintEnd = std::find(I, E, ',');
217 if (ConstraintEnd == I || // Empty constraint like ",,"
218 Info.Parse(StringRef(I, ConstraintEnd-I), Result)) {
219 Result.clear(); // Erroneous constraint?
223 Result.push_back(Info);
225 // ConstraintEnd may be either the next comma or the end of the string. In
226 // the former case, we skip the comma.
233 } // don't allow "xyz,"
240 /// Verify - Verify that the specified constraint string is reasonable for the
241 /// specified function type, and otherwise validate the constraint string.
242 bool InlineAsm::Verify(FunctionType *Ty, StringRef ConstStr) {
243 if (Ty->isVarArg()) return false;
245 ConstraintInfoVector Constraints = ParseConstraints(ConstStr);
247 // Error parsing constraints.
248 if (Constraints.empty() && !ConstStr.empty()) return false;
250 unsigned NumOutputs = 0, NumInputs = 0, NumClobbers = 0;
251 unsigned NumIndirect = 0;
253 for (unsigned i = 0, e = Constraints.size(); i != e; ++i) {
254 switch (Constraints[i].Type) {
255 case InlineAsm::isOutput:
256 if ((NumInputs-NumIndirect) != 0 || NumClobbers != 0)
257 return false; // outputs before inputs and clobbers.
258 if (!Constraints[i].isIndirect) {
263 LLVM_FALLTHROUGH; // We fall through for Indirect Outputs.
264 case InlineAsm::isInput:
265 if (NumClobbers) return false; // inputs before clobbers.
268 case InlineAsm::isClobber:
274 switch (NumOutputs) {
276 if (!Ty->getReturnType()->isVoidTy()) return false;
279 if (Ty->getReturnType()->isStructTy()) return false;
282 StructType *STy = dyn_cast<StructType>(Ty->getReturnType());
283 if (!STy || STy->getNumElements() != NumOutputs)
288 if (Ty->getNumParams() != NumInputs) return false;