From: Chris Lattner Date: Wed, 1 Feb 2006 01:29:47 +0000 (+0000) Subject: Beef up the interface to inline asm constraint parsing, making it more general, usefu... X-Git-Url: http://plrg.eecs.uci.edu/git/?a=commitdiff_plain;h=a55079a5ccdf0cdb4d482fb47a3fb21825f56713;p=oota-llvm.git Beef up the interface to inline asm constraint parsing, making it more general, useful, and easier to use. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@25866 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/lib/CodeGen/SelectionDAG/TargetLowering.cpp b/lib/CodeGen/SelectionDAG/TargetLowering.cpp index edb98f3817f..c861762d16d 100644 --- a/lib/CodeGen/SelectionDAG/TargetLowering.cpp +++ b/lib/CodeGen/SelectionDAG/TargetLowering.cpp @@ -243,15 +243,22 @@ bool TargetLowering::isMaskedValueZeroForTargetNode(const SDOperand &Op, std::vector TargetLowering:: getRegForInlineAsmConstraint(const std::string &Constraint) const { + // Not a physreg, must not be a register reference or something. + if (Constraint[0] != '{') return std::vector(); + assert(*(Constraint.end()-1) == '}' && "Not a brace enclosed constraint?"); + + // Remove the braces from around the name. + std::string RegName(Constraint.begin()+1, Constraint.end()-1); + // Scan to see if this constraint is a register name. const MRegisterInfo *RI = TM.getRegisterInfo(); for (unsigned i = 1, e = RI->getNumRegs(); i != e; ++i) { if (const char *Name = RI->get(i).Name) - if (StringsEqualNoCase(Constraint, Name)) + if (StringsEqualNoCase(RegName, Name)) return std::vector(1, i); } - - // Not a physreg, must not be a register reference or something. + + // Unknown physreg. return std::vector(); } diff --git a/lib/VMCore/InlineAsm.cpp b/lib/VMCore/InlineAsm.cpp index e9a81e4ed88..430fb07008e 100644 --- a/lib/VMCore/InlineAsm.cpp +++ b/lib/VMCore/InlineAsm.cpp @@ -38,50 +38,101 @@ const FunctionType *InlineAsm::getFunctionType() const { return cast(getType()->getElementType()); } -std::vector > -InlineAsm::ParseConstraints(const std::string &Constraints) { - std::vector > Result; +/// Parse - Analyze the specified string (e.g. "==&{eax}") and fill in the +/// fields in this structure. If the constraint string is not understood, +/// return true, otherwise return false. +bool InlineAsm::ConstraintInfo::Parse(const std::string &Str) { + std::string::const_iterator I = Str.begin(), E = Str.end(); - // Scan the constraints string. - for (std::string::const_iterator I = Constraints.begin(), - E = Constraints.end(); I != E; ) { - if (*I == ',') { Result.clear(); break; } // Empty constraint like ",," - - // Parse the prefix. - ConstraintPrefix ConstraintType = isInput; - - if (*I == '~') { - ConstraintType = isClobber; + // Initialize + Type = isInput; + isEarlyClobber = false; + isIndirectOutput =false; + + // Parse the prefix. + if (*I == '~') { + Type = isClobber; + ++I; + } else if (*I == '=') { + ++I; + Type = isOutput; + if (I != E && *I == '=') { + isIndirectOutput = true; ++I; - } else if (*I == '=') { + } + } + + if (I == E) return true; // Just a prefix, like "==" or "~". + + // Parse the modifiers. + bool DoneWithModifiers = false; + while (!DoneWithModifiers) { + switch (*I) { + default: + DoneWithModifiers = true; + break; + case '&': + if (Type != isOutput || // Cannot early clobber anything but output. + isEarlyClobber) // Reject &&&&&& + return true; + isEarlyClobber = true; + break; + } + + if (!DoneWithModifiers) { ++I; - if (I != E && *I == '=') { - ConstraintType = isIndirectOutput; + if (I == E) return true; // Just prefixes and modifiers! + } + } + + // Parse the various constraints. + while (I != E) { + if (*I == '{') { // Physical register reference. + // Find the end of the register name. + std::string::const_iterator ConstraintEnd = std::find(I+1, E, '}'); + if (ConstraintEnd == E) return true; // "{foo" + Codes.push_back(std::string(I, ConstraintEnd+1)); + I = ConstraintEnd+1; + } else if (isdigit(*I)) { + // Maximal munch numbers. + std::string::const_iterator NumStart = I; + while (I != E && isdigit(*I)) ++I; - } else { - ConstraintType = isOutput; - } + Codes.push_back(std::string(NumStart, I)); + } else { + // Single letter constraint. + Codes.push_back(std::string(I, I+1)); + ++I; } - - if (I == E) { Result.clear(); break; } // Just a prefix, like "==" or "~". - - std::string::const_iterator IdStart = I; - - // Parse the id. We accept [a-zA-Z0-9] currently. - while (I != E && isalnum(*I)) ++I; - - if (IdStart == I) { // Requires more than just a prefix + } + + return false; +} + +std::vector +InlineAsm::ParseConstraints(const std::string &Constraints) { + std::vector Result; + + // Scan the constraints string. + for (std::string::const_iterator I = Constraints.begin(), + E = Constraints.end(); I != E; ) { + ConstraintInfo Info; + + // Find the end of this constraint. + std::string::const_iterator ConstraintEnd = std::find(I, E, ','); + + if (ConstraintEnd == I || // Empty constraint like ",," + Info.Parse(std::string(I, ConstraintEnd))) { // Erroneous constraint? Result.clear(); break; } + + Result.push_back(Info); - // Remember this constraint. - Result.push_back(std::make_pair(ConstraintType, std::string(IdStart, I))); - - // If we reached the end of the ID, we must have the end of the string or a - // comma, which we skip now. + // ConstraintEnd may be either the next comma or the end of the string. In + // the former case, we skip the comma. + I = ConstraintEnd; if (I != E) { - if (*I != ',') { Result.clear(); break; } ++I; if (I == E) { Result.clear(); break; } // don't allow "xyz," } @@ -96,8 +147,7 @@ InlineAsm::ParseConstraints(const std::string &Constraints) { bool InlineAsm::Verify(const FunctionType *Ty, const std::string &ConstStr) { if (Ty->isVarArg()) return false; - std::vector > - Constraints = ParseConstraints(ConstStr); + std::vector Constraints = ParseConstraints(ConstStr); // Error parsing constraints. if (Constraints.empty() && !ConstStr.empty()) return false; @@ -105,17 +155,19 @@ bool InlineAsm::Verify(const FunctionType *Ty, const std::string &ConstStr) { unsigned NumOutputs = 0, NumInputs = 0, NumClobbers = 0; for (unsigned i = 0, e = Constraints.size(); i != e; ++i) { - switch (Constraints[i].first) { - case isOutput: - if (NumInputs || NumClobbers) return false; // outputs come first. - ++NumOutputs; - break; - case isInput: - case isIndirectOutput: + switch (Constraints[i].Type) { + case InlineAsm::isOutput: + if (!Constraints[i].isIndirectOutput) { + if (NumInputs || NumClobbers) return false; // outputs come first. + ++NumOutputs; + break; + } + // FALLTHROUGH for IndirectOutputs. + case InlineAsm::isInput: if (NumClobbers) return false; // inputs before clobbers. ++NumInputs; break; - case isClobber: + case InlineAsm::isClobber: ++NumClobbers; break; }