X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FInlineAsm.h;h=325b777dd49f8644de44f2e87c196c7fa479fd5a;hb=4ae641f4d12c60ee1aaca5e42b6de231c6a02c40;hp=f80ddc0b131277947bc9701c4696699dea017d7f;hpb=c73fe2ac0cbb79dd37fe7be863b4d2cae280c47a;p=oota-llvm.git diff --git a/include/llvm/InlineAsm.h b/include/llvm/InlineAsm.h index f80ddc0b131..325b777dd49 100644 --- a/include/llvm/InlineAsm.h +++ b/include/llvm/InlineAsm.h @@ -2,13 +2,14 @@ // // 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. // //===----------------------------------------------------------------------===// // // This class represents the inline asm strings, which are Value*'s that are -// used as the callee operand of call instructions. +// used as the callee operand of call instructions. InlineAsm's are uniqued +// like constants, and created via InlineAsm::get(...). // //===----------------------------------------------------------------------===// @@ -16,42 +17,32 @@ #define LLVM_INLINEASM_H #include "llvm/Value.h" +#include namespace llvm { -struct AssemblyAnnotationWriter; class PointerType; class FunctionType; class Module; -template struct ilist_traits; -template class SymbolTableListTraits; class InlineAsm : public Value { - friend class SymbolTableListTraits >; InlineAsm(const InlineAsm &); // do not implement void operator=(const InlineAsm&); // do not implement - void setParent(Module *Parent); - InlineAsm *Prev, *Next; - void setNext(InlineAsm *N) { Next = N; } - void setPrev(InlineAsm *N) { Prev = N; } - InlineAsm *getNext() { return Next; } - const InlineAsm *getNext() const { return Next; } - InlineAsm *getPrev() { return Prev; } - const InlineAsm *getPrev() const { return Prev; } - - Module *Parent; std::string AsmString, Constraints; - bool AsmHasSideEffects; -public: + bool HasSideEffects; + InlineAsm(const FunctionType *Ty, const std::string &AsmString, - const std::string &Constraints, bool hasSideEffects, - const std::string &Name = "", Module *ParentModule = 0); + const std::string &Constraints, bool hasSideEffects); + virtual ~InlineAsm(); +public: + + /// InlineAsm::get - Return the the specified uniqued inline asm string. + /// + static InlineAsm *get(const FunctionType *Ty, const std::string &AsmString, + const std::string &Constraints, bool hasSideEffects); - bool getHasSideEffects() const { return AsmHasSideEffects; } - void setSideEffects(bool X) { AsmHasSideEffects = X; } + bool hasSideEffects() const { return HasSideEffects; } /// getType - InlineAsm's are always pointers. /// @@ -62,25 +53,74 @@ public: /// getFunctionType - InlineAsm's are always pointers to functions. /// const FunctionType *getFunctionType() const; + + const std::string &getAsmString() const { return AsmString; } + const std::string &getConstraintString() const { return Constraints; } - /// getParent - Get the module that this global value is contained inside - /// of... - Module *getParent() { return Parent; } - const Module *getParent() const { return Parent; } + /// Verify - This static method can be used by the parser to check to see if + /// the specified constraint string is legal for the type. This returns true + /// if legal, false if not. + /// + static bool Verify(const FunctionType *Ty, const std::string &Constraints); + // Constraint String Parsing + enum ConstraintPrefix { + isInput, // 'x' + isOutput, // '=x' + isClobber // '~x' + }; - /// removeFromParent/eraseFromParent - Unlink and unlink/delete this object - /// from the module it is embedded into. - void removeFromParent(); - void eraseFromParent(); + struct ConstraintInfo { + /// Type - The basic type of the constraint: input/output/clobber + /// + ConstraintPrefix Type; + + /// isEarlyClobber - "&": output operand writes result before inputs are all + /// read. This is only ever set for an output operand. + bool isEarlyClobber; + + /// hasMatchingInput - This is set to true for an output constraint iff + /// there is an input constraint that is required to match it (e.g. "0"). + bool hasMatchingInput; + + /// isCommutative - This is set to true for a constraint that is commutative + /// with the next operand. + bool isCommutative; + + /// isIndirect - True if this operand is an indirect operand. This means + /// that the address of the source or destination is present in the call + /// instruction, instead of it being returned or passed in explicitly. This + /// is represented with a '*' in the asm string. + bool isIndirect; + + /// Code - The constraint code, either the register name (in braces) or the + /// constraint letter/number. + std::vector Codes; + + /// 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 Parse(const std::string &Str, + std::vector &ConstraintsSoFar); + }; + + /// ParseConstraints - Split up the constraint string into the specific + /// constraints and their prefixes. If this returns an empty vector, and if + /// the constraint string itself isn't empty, there was an error parsing. + static std::vector + ParseConstraints(const std::string &ConstraintString); + + /// ParseConstraints - Parse the constraints of this inlineasm object, + /// returning them the same way that ParseConstraints(str) does. + std::vector + ParseConstraints() const { + return ParseConstraints(Constraints); + } - virtual void print(std::ostream &O) const { print(O, 0); } - void print(std::ostream &OS, AssemblyAnnotationWriter *AAW) const; - // Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const InlineAsm *) { return true; } static inline bool classof(const Value *V) { - return V->getValueType() == Value::InlineAsmVal; + return V->getValueID() == Value::InlineAsmVal; } };