X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FInlineAsm.cpp;h=0520dfa17cedadf96ab4423b588ea2155501417e;hb=158d86e5b0d0a11bfce694b16bafb60c7f9507ff;hp=430fb07008e383caa79516206596dfc1bad16cf1;hpb=a55079a5ccdf0cdb4d482fb47a3fb21825f56713;p=oota-llvm.git diff --git a/lib/VMCore/InlineAsm.cpp b/lib/VMCore/InlineAsm.cpp index 430fb07008e..0520dfa17ce 100644 --- a/lib/VMCore/InlineAsm.cpp +++ b/lib/VMCore/InlineAsm.cpp @@ -2,8 +2,8 @@ // // The LLVM Compiler Infrastructure // -// This file was developed by Chris Lattner and is distributed under the -// University of Illinois Open Source License. See LICENSE.TXT for details. +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // @@ -13,22 +13,33 @@ #include "llvm/InlineAsm.h" #include "llvm/DerivedTypes.h" +#include #include using namespace llvm; +// Implement the first virtual method in this class in this file so the +// InlineAsm vtable is emitted here. +InlineAsm::~InlineAsm() { +} + + // NOTE: when memoizing the function type, we have to be careful to handle the // case when the type gets refined. -InlineAsm *InlineAsm::get(const FunctionType *Ty, const std::string &AsmString, - const std::string &Constraints, bool hasSideEffects) { +InlineAsm *InlineAsm::get(const FunctionType *Ty, const StringRef &AsmString, + const StringRef &Constraints, bool hasSideEffects, + bool isMsAsm) { // FIXME: memoize! - return new InlineAsm(Ty, AsmString, Constraints, hasSideEffects); + return new InlineAsm(Ty, AsmString, Constraints, hasSideEffects, isMsAsm); } -InlineAsm::InlineAsm(const FunctionType *Ty, const std::string &asmString, - const std::string &constraints, bool hasSideEffects) - : Value(PointerType::get(Ty), Value::InlineAsmVal), AsmString(asmString), - Constraints(constraints), HasSideEffects(hasSideEffects) { +InlineAsm::InlineAsm(const FunctionType *Ty, const StringRef &asmString, + const StringRef &constraints, bool hasSideEffects, + bool isMsAsm) + : Value(PointerType::getUnqual(Ty), + Value::InlineAsmVal), + AsmString(asmString), + Constraints(constraints), HasSideEffects(hasSideEffects), IsMsAsm(isMsAsm) { // Do various checks on the constraint string and type. assert(Verify(Ty, constraints) && "Function type not legal for constraints!"); @@ -41,25 +52,29 @@ const FunctionType *InlineAsm::getFunctionType() const { /// 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(); +bool InlineAsm::ConstraintInfo::Parse(const StringRef &Str, + std::vector &ConstraintsSoFar) { + StringRef::iterator I = Str.begin(), E = Str.end(); // Initialize Type = isInput; isEarlyClobber = false; - isIndirectOutput =false; + MatchingInput = -1; + isCommutative = false; + isIndirect = false; - // Parse the prefix. + // Parse prefixes. if (*I == '~') { Type = isClobber; ++I; } else if (*I == '=') { ++I; Type = isOutput; - if (I != E && *I == '=') { - isIndirectOutput = true; - ++I; - } + } + + if (*I == '*') { + isIndirect = true; + ++I; } if (I == E) return true; // Just a prefix, like "==" or "~". @@ -71,12 +86,21 @@ bool InlineAsm::ConstraintInfo::Parse(const std::string &Str) { default: DoneWithModifiers = true; break; - case '&': + case '&': // Early clobber. if (Type != isOutput || // Cannot early clobber anything but output. isEarlyClobber) // Reject &&&&&& return true; isEarlyClobber = true; break; + case '%': // Commutative. + if (Type == isClobber || // Cannot commute clobbers. + isCommutative) // Reject %%%%% + return true; + isCommutative = true; + break; + case '#': // Comment. + case '*': // Register preferencing. + return true; // Not supported. } if (!DoneWithModifiers) { @@ -89,16 +113,29 @@ bool InlineAsm::ConstraintInfo::Parse(const std::string &Str) { 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, '}'); + StringRef::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)) { + } else if (isdigit(*I)) { // Matching Constraint // Maximal munch numbers. - std::string::const_iterator NumStart = I; + StringRef::iterator NumStart = I; while (I != E && isdigit(*I)) ++I; Codes.push_back(std::string(NumStart, I)); + unsigned N = atoi(Codes.back().c_str()); + // Check that this is a valid matching constraint! + if (N >= ConstraintsSoFar.size() || ConstraintsSoFar[N].Type != isOutput|| + Type != isInput) + return true; // Invalid constraint number. + + // If Operand N already has a matching input, reject this. An output + // can't be constrained to the same value as multiple inputs. + if (ConstraintsSoFar[N].hasMatchingInput()) + return true; + + // Note that operand #n has a matching input. + ConstraintsSoFar[N].MatchingInput = ConstraintsSoFar.size(); } else { // Single letter constraint. Codes.push_back(std::string(I, I+1)); @@ -110,20 +147,20 @@ bool InlineAsm::ConstraintInfo::Parse(const std::string &Str) { } std::vector -InlineAsm::ParseConstraints(const std::string &Constraints) { +InlineAsm::ParseConstraints(const StringRef &Constraints) { std::vector Result; // Scan the constraints string. - for (std::string::const_iterator I = Constraints.begin(), - E = Constraints.end(); I != E; ) { + for (StringRef::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, ','); + StringRef::iterator ConstraintEnd = std::find(I, E, ','); if (ConstraintEnd == I || // Empty constraint like ",," - Info.Parse(std::string(I, ConstraintEnd))) { // Erroneous constraint? - Result.clear(); + Info.Parse(std::string(I, ConstraintEnd), Result)) { + Result.clear(); // Erroneous constraint? break; } @@ -144,7 +181,7 @@ InlineAsm::ParseConstraints(const std::string &Constraints) { /// Verify - Verify that the specified constraint string is reasonable for the /// specified function type, and otherwise validate the constraint string. -bool InlineAsm::Verify(const FunctionType *Ty, const std::string &ConstStr) { +bool InlineAsm::Verify(const FunctionType *Ty, const StringRef &ConstStr) { if (Ty->isVarArg()) return false; std::vector Constraints = ParseConstraints(ConstStr); @@ -153,16 +190,19 @@ bool InlineAsm::Verify(const FunctionType *Ty, const std::string &ConstStr) { if (Constraints.empty() && !ConstStr.empty()) return false; unsigned NumOutputs = 0, NumInputs = 0, NumClobbers = 0; + unsigned NumIndirect = 0; for (unsigned i = 0, e = Constraints.size(); i != e; ++i) { switch (Constraints[i].Type) { case InlineAsm::isOutput: - if (!Constraints[i].isIndirectOutput) { - if (NumInputs || NumClobbers) return false; // outputs come first. + if ((NumInputs-NumIndirect) != 0 || NumClobbers != 0) + return false; // outputs before inputs and clobbers. + if (!Constraints[i].isIndirect) { ++NumOutputs; break; } - // FALLTHROUGH for IndirectOutputs. + ++NumIndirect; + // FALLTHROUGH for Indirect Outputs. case InlineAsm::isInput: if (NumClobbers) return false; // inputs before clobbers. ++NumInputs; @@ -172,12 +212,22 @@ bool InlineAsm::Verify(const FunctionType *Ty, const std::string &ConstStr) { break; } } - - if (NumOutputs > 1) return false; // Only one result allowed so far. - if ((Ty->getReturnType() != Type::VoidTy) != NumOutputs) - return false; // NumOutputs = 1 iff has a result type. + switch (NumOutputs) { + case 0: + if (Ty->getReturnType() != Type::getVoidTy(Ty->getContext())) return false; + break; + case 1: + if (isa(Ty->getReturnType())) return false; + break; + default: + const StructType *STy = dyn_cast(Ty->getReturnType()); + if (STy == 0 || STy->getNumElements() != NumOutputs) + return false; + break; + } if (Ty->getNumParams() != NumInputs) return false; return true; } +