Parse inline asm objects
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@25618 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/lib/AsmParser/Lexer.l b/lib/AsmParser/Lexer.l
index 772023b..71482e0 100644
--- a/lib/AsmParser/Lexer.l
+++ b/lib/AsmParser/Lexer.l
@@ -214,6 +214,7 @@
section { return SECTION; }
module { return MODULE; }
asm { return ASM_TOK; }
+sideeffect { return SIDEEFFECT; }
cc { return CC_TOK; }
ccc { return CCC_TOK; }
diff --git a/lib/AsmParser/ParserInternals.h b/lib/AsmParser/ParserInternals.h
index 6f747c7..820e5ba 100644
--- a/lib/AsmParser/ParserInternals.h
+++ b/lib/AsmParser/ParserInternals.h
@@ -72,6 +72,17 @@
throw ParseException(CurFilename, message, LineNo);
}
+/// InlineAsmDescriptor - This is a simple class that holds info about inline
+/// asm blocks, for use by ValID.
+struct InlineAsmDescriptor {
+ std::string AsmString, Constraints;
+ bool HasSideEffects;
+
+ InlineAsmDescriptor(const std::string &as, const std::string &c, bool HSE)
+ : AsmString(as), Constraints(c), HasSideEffects(HSE) {}
+};
+
+
// ValID - Represents a reference of a definition of some sort. This may either
// be a numeric reference or a symbolic (%var) reference. This is just a
// discriminated union.
@@ -82,7 +93,7 @@
struct ValID {
enum {
NumberVal, NameVal, ConstSIntVal, ConstUIntVal, ConstFPVal, ConstNullVal,
- ConstUndefVal, ConstZeroVal, ConstantVal,
+ ConstUndefVal, ConstZeroVal, ConstantVal, InlineAsmVal
} Type;
union {
@@ -92,6 +103,7 @@
uint64_t UConstPool64;// Unsigned constant pool reference.
double ConstPoolFP; // Floating point constant pool reference
Constant *ConstantValue; // Fully resolved constant for ConstantVal case.
+ InlineAsmDescriptor *IAD;
};
static ValID create(int Num) {
@@ -129,10 +141,21 @@
static ValID create(Constant *Val) {
ValID D; D.Type = ConstantVal; D.ConstantValue = Val; return D;
}
+
+ static ValID createInlineAsm(const std::string &AsmString,
+ const std::string &Constraints,
+ bool HasSideEffects) {
+ ValID D;
+ D.Type = InlineAsmVal;
+ D.IAD = new InlineAsmDescriptor(AsmString, Constraints, HasSideEffects);
+ return D;
+ }
inline void destroy() const {
if (Type == NameVal)
- free(Name); // Free this strdup'd memory...
+ free(Name); // Free this strdup'd memory.
+ else if (Type == InlineAsmVal)
+ delete IAD;
}
inline ValID copy() const {
diff --git a/lib/AsmParser/llvmAsmParser.y b/lib/AsmParser/llvmAsmParser.y
index b859778..dfdb5f4 100644
--- a/lib/AsmParser/llvmAsmParser.y
+++ b/lib/AsmParser/llvmAsmParser.y
@@ -14,6 +14,7 @@
%{
#include "ParserInternals.h"
#include "llvm/CallingConv.h"
+#include "llvm/InlineAsm.h"
#include "llvm/Instructions.h"
#include "llvm/Module.h"
#include "llvm/SymbolTable.h"
@@ -316,6 +317,17 @@
ThrowException("Constant expression type different from required type!");
return D.ConstantValue;
+ case ValID::InlineAsmVal: { // Inline asm expression
+ const PointerType *PTy = dyn_cast<PointerType>(Ty);
+ const FunctionType *FTy =
+ PTy ? dyn_cast<FunctionType>(PTy->getElementType()) : 0;
+ if (!FTy || !InlineAsm::Verify(FTy, D.IAD->Constraints))
+ ThrowException("Invalid type for asm constraint string!");
+ InlineAsm *IA = InlineAsm::get(FTy, D.IAD->AsmString, D.IAD->Constraints,
+ D.IAD->HasSideEffects);
+ D.destroy(); // Free InlineAsmDescriptor.
+ return IA;
+ }
default:
assert(0 && "Unhandled case!");
return 0;
@@ -932,6 +944,7 @@
%type <BoolVal> GlobalType // GLOBAL or CONSTANT?
%type <BoolVal> OptVolatile // 'volatile' or not
%type <BoolVal> OptTailCall // TAIL CALL or plain CALL.
+%type <BoolVal> OptSideEffect // 'sideeffect' or not.
%type <Linkage> OptLinkage
%type <Endianness> BigOrLittle
@@ -967,7 +980,7 @@
%token DECLARE GLOBAL CONSTANT SECTION VOLATILE
%token TO DOTDOTDOT NULL_TOK UNDEF CONST INTERNAL LINKONCE WEAK APPENDING
%token OPAQUE NOT EXTERNAL TARGET TRIPLE ENDIAN POINTERSIZE LITTLE BIG ALIGN
-%token DEPLIBS CALL TAIL ASM_TOK MODULE
+%token DEPLIBS CALL TAIL ASM_TOK MODULE SIDEEFFECT
%token CC_TOK CCC_TOK FASTCC_TOK COLDCC_TOK
%type <UIntVal> OptCallingConv
@@ -1831,6 +1844,13 @@
// Rules to match Basic Blocks
//===----------------------------------------------------------------------===//
+OptSideEffect : /* empty */ {
+ $$ = false;
+ }
+ | SIDEEFFECT {
+ $$ = true;
+ };
+
ConstValueRef : ESINT64VAL { // A reference to a direct constant
$$ = ValID::create($1);
}
@@ -1881,6 +1901,15 @@
}
| ConstExpr {
$$ = ValID::create($1);
+ }
+ | ASM_TOK OptSideEffect STRINGCONSTANT ',' STRINGCONSTANT {
+ char *End = UnEscapeLexed($3, true);
+ std::string AsmStr = std::string($3, End);
+ End = UnEscapeLexed($5, true);
+ std::string Constraints = std::string($5, End);
+ $$ = ValID::createInlineAsm(AsmStr, Constraints, $2);
+ free($3);
+ free($5);
};
// SymbolicValueRef - Reference to one of two ways of symbolically refering to