X-Git-Url: http://plrg.eecs.uci.edu/git/?p=oota-llvm.git;a=blobdiff_plain;f=lib%2FAsmParser%2FllvmAsmParser.y;h=57b6f81d8fb756b34096b3bbb4a1d09b6947b865;hp=c47b6fc6ea9062d2e65b7dbd2f78c8326c339c22;hb=80a75bfae980df96f969f1c05b0c4a80ce975240;hpb=863dd88cc5b7fb0ee78b54c2adfa34fcaab872f2 diff --git a/lib/AsmParser/llvmAsmParser.y b/lib/AsmParser/llvmAsmParser.y index c47b6fc6ea9..57b6f81d8fb 100644 --- a/lib/AsmParser/llvmAsmParser.y +++ b/lib/AsmParser/llvmAsmParser.y @@ -18,6 +18,7 @@ #include "llvm/Instructions.h" #include "llvm/Module.h" #include "llvm/ValueSymbolTable.h" +#include "llvm/AutoUpgrade.h" #include "llvm/Support/GetElementPtrTypeIterator.h" #include "llvm/Support/CommandLine.h" #include "llvm/ADT/SmallVector.h" @@ -28,9 +29,6 @@ #include #include #include -#ifndef NDEBUG -#define YYDEBUG 1 -#endif // The following is a gross hack. In order to rid the libAsmParser library of // exceptions, we have to have a way of getting the yyparse function to go into @@ -50,15 +48,6 @@ static bool TriggerError = false; int yyerror(const char *ErrorMsg); // Forward declarations to prevent "implicit int yylex(); // declaration" of xxx warnings. int yyparse(); - -namespace llvm { - std::string CurFilename; -#if YYDEBUG -static cl::opt -Debug("debug-yacc", cl::desc("Print yacc debug state changes"), - cl::Hidden, cl::init(false)); -#endif -} using namespace llvm; static Module *ParserResult; @@ -131,6 +120,11 @@ static struct PerModuleInfo { return; } + // Look for intrinsic functions and CallInst that need to be upgraded + for (Module::iterator FI = CurrentModule->begin(), + FE = CurrentModule->end(); FI != FE; ) + UpgradeCallsToIntrinsic(FI++); // must be post-increment, as we remove + Values.clear(); // Clear out function local definitions Types.clear(); CurrentModule = 0; @@ -282,7 +276,7 @@ static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) { return CurModule.Types[D.Num]; break; case ValID::LocalName: // Is it a named definition? - if (const Type *N = CurModule.CurrentModule->getTypeByName(D.Name)) { + if (const Type *N = CurModule.CurrentModule->getTypeByName(D.getName())) { D.destroy(); // Free old strdup'd memory... return N; } @@ -360,7 +354,7 @@ static Value *getExistingVal(const Type *Ty, const ValID &D) { if (!inFunctionScope()) return 0; ValueSymbolTable &SymTab = CurFun.CurrentFunction->getValueSymbolTable(); - Value *N = SymTab.lookup(D.Name); + Value *N = SymTab.lookup(D.getName()); if (N == 0) return 0; if (N->getType() != Ty) @@ -371,7 +365,7 @@ static Value *getExistingVal(const Type *Ty, const ValID &D) { } case ValID::GlobalName: { // Is it a named definition? ValueSymbolTable &SymTab = CurModule.CurrentModule->getValueSymbolTable(); - Value *N = SymTab.lookup(D.Name); + Value *N = SymTab.lookup(D.getName()); if (N == 0) return 0; if (N->getType() != Ty) @@ -406,11 +400,16 @@ static Value *getExistingVal(const Type *Ty, const ValID &D) { } case ValID::ConstFPVal: // Is it a floating point const pool reference? - if (!ConstantFP::isValueValidForType(Ty, D.ConstPoolFP)) { + if (!ConstantFP::isValueValidForType(Ty, *D.ConstPoolFP)) { GenerateError("FP constant invalid for type"); return 0; } - return ConstantFP::get(Ty, D.ConstPoolFP); + // Lexer has no type info, so builds all float and double FP constants + // as double. Fix this here. Long double does not need this. + if (&D.ConstPoolFP->getSemantics() == &APFloat::IEEEdouble && + Ty==Type::FloatTy) + D.ConstPoolFP->convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven); + return ConstantFP::get(Ty, *D.ConstPoolFP); case ValID::ConstNullVal: // Is it a null value? if (!isa(Ty)) { @@ -502,7 +501,7 @@ static Value *getVal(const Type *Ty, const ValID &ID) { // Remember where this forward reference came from. FIXME, shouldn't we try // to recycle these things?? CurModule.PlaceHolderInfo.insert(std::make_pair(V, std::make_pair(ID, - llvmAsmlineno))); + LLLgetLineNo()))); if (inFunctionScope()) InsertValue(V, CurFun.LateResolveValues); @@ -550,7 +549,7 @@ static BasicBlock *defineBBVal(const ValID &ID) { // We haven't seen this BB before and its first mention is a definition. // Just create it and return it. - std::string Name (ID.Type == ValID::LocalName ? ID.Name : ""); + std::string Name (ID.Type == ValID::LocalName ? ID.getName() : ""); BB = new BasicBlock(Name, CurFun.CurrentFunction); if (ID.Type == ValID::LocalID) { assert(ID.Num == CurFun.NextValNum && "Invalid new block number"); @@ -572,7 +571,7 @@ static BasicBlock *getBBVal(const ValID &ID) { if (BBI != CurFun.BBForwardRefs.end()) { BB = BBI->second; } if (ID.Type == ValID::LocalName) { - std::string Name = ID.Name; + std::string Name = ID.getName(); Value *N = CurFun.CurrentFunction->getValueSymbolTable().lookup(Name); if (N) if (N->getType()->getTypeID() == Type::LabelTyID) @@ -603,7 +602,7 @@ static BasicBlock *getBBVal(const ValID &ID) { // Otherwise, this block has not been seen before, create it. std::string Name; if (ID.Type == ValID::LocalName) - Name = ID.Name; + Name = ID.getName(); BB = new BasicBlock(Name, CurFun.CurrentFunction); // Insert it in the forward refs map. @@ -675,10 +674,12 @@ ResolveDefinitions(ValueList &LateResolvers, ValueList *FutureLateResolvers) { // name is not null) things referencing Name can be resolved. Otherwise, things // refering to the number can be resolved. Do this now. // -static void ResolveTypeTo(char *Name, const Type *ToTy) { +static void ResolveTypeTo(std::string *Name, const Type *ToTy) { ValID D; - if (Name) D = ValID::createLocalName(Name); - else D = ValID::createLocalID(CurModule.Types.size()); + if (Name) + D = ValID::createLocalName(*Name); + else + D = ValID::createLocalID(CurModule.Types.size()); std::map::iterator I = CurModule.LateResolveTypes.find(D); @@ -692,10 +693,10 @@ static void ResolveTypeTo(char *Name, const Type *ToTy) { // null potentially, in which case this is a noop. The string passed in is // assumed to be a malloc'd string buffer, and is free'd by this function. // -static void setValueName(Value *V, char *NameStr) { +static void setValueName(Value *V, std::string *NameStr) { if (!NameStr) return; - std::string Name(NameStr); // Copy string - free(NameStr); // Free old string + std::string Name(*NameStr); // Copy string + delete NameStr; // Free old string if (V->getType() == Type::VoidTy) { GenerateError("Can't assign name '" + Name+"' to value with void type"); @@ -717,7 +718,7 @@ static void setValueName(Value *V, char *NameStr) { /// ParseGlobalVariable - Handle parsing of a global. If Initializer is null, /// this is a declaration, otherwise it is a definition. static GlobalVariable * -ParseGlobalVariable(char *NameStr, +ParseGlobalVariable(std::string *NameStr, GlobalValue::LinkageTypes Linkage, GlobalValue::VisibilityTypes Visibility, bool isConstantGlobal, const Type *Ty, @@ -731,15 +732,15 @@ ParseGlobalVariable(char *NameStr, std::string Name; if (NameStr) { - Name = NameStr; // Copy string - free(NameStr); // Free old string + Name = *NameStr; // Copy string + delete NameStr; // Free old string } // See if this global value was forward referenced. If so, recycle the // object. ValID ID; if (!Name.empty()) { - ID = ValID::createGlobalName((char*)Name.c_str()); + ID = ValID::createGlobalName(Name); } else { ID = ValID::createGlobalID(CurModule.Values.size()); } @@ -792,12 +793,12 @@ ParseGlobalVariable(char *NameStr, // This function returns true if the type has already been defined, but is // allowed to be redefined in the specified context. If the name is a new name // for the type plane, it is inserted and false is returned. -static bool setTypeName(const Type *T, char *NameStr) { +static bool setTypeName(const Type *T, std::string *NameStr) { assert(!inFunctionScope() && "Can't give types function-local names!"); if (NameStr == 0) return false; - std::string Name(NameStr); // Copy string - free(NameStr); // Free old string + std::string Name(*NameStr); // Copy string + delete NameStr; // Free old string // We don't allow assigning names to void type if (T == Type::VoidTy) { @@ -932,22 +933,11 @@ static PATypeHolder HandleUpRefs(const Type *ty) { // static Module* RunParser(Module * M); -Module *llvm::RunVMAsmParser(const std::string &Filename, FILE *F) { - set_scan_file(F); - - CurFilename = Filename; - return RunParser(new Module(CurFilename)); -} - -Module *llvm::RunVMAsmParser(const char * AsmString, Module * M) { - set_scan_string(AsmString); - - CurFilename = "from_memory"; - if (M == NULL) { - return RunParser(new Module (CurFilename)); - } else { - return RunParser(M); - } +Module *llvm::RunVMAsmParser(llvm::MemoryBuffer *MB) { + InitLLLexer(MB); + Module *M = RunParser(new Module(LLLgetFilename())); + FreeLexer(); + return M; } %} @@ -968,7 +958,7 @@ Module *llvm::RunVMAsmParser(const char * AsmString, Module * M) { llvm::ArgListType *ArgList; llvm::TypeWithAttrs TypeWithAttrs; llvm::TypeWithAttrsList *TypeWithAttrsList; - llvm::ValueRefList *ValueRefList; + llvm::ParamList *ParamList; // Represent the RHS of PHI node std::list ConstVector %type ArgList ArgListH %type PHIList -%type ValueRefList // For call param lists & GEP indices +%type ParamList // For call param lists & GEP indices %type IndexList // For GEP indices %type TypeListI %type ArgTypeList ArgTypeListI @@ -1048,14 +1038,17 @@ Module *llvm::RunVMAsmParser(const char * AsmString, Module * M) { %type Types ResultTypes %type IntType FPType PrimType // Classifications %token VOID INTTYPE -%token FLOAT DOUBLE LABEL +%token FLOAT DOUBLE X86_FP80 FP128 PPC_FP128 LABEL %token TYPE -%token LOCALVAR GLOBALVAR LABELSTR STRINGCONSTANT ATSTRINGCONSTANT + +%token LOCALVAR GLOBALVAR LABELSTR +%token STRINGCONSTANT ATSTRINGCONSTANT PCTSTRINGCONSTANT %type LocalName OptLocalName OptLocalAssign %type GlobalName OptGlobalAssign GlobalAssign +%type OptSection SectionString OptGC + %type OptAlign OptCAlign -%type OptSection SectionString %token ZEROINITIALIZER TRUETOK FALSETOK BEGINTOK ENDTOK %token DECLARE DEFINE GLOBAL CONSTANT SECTION ALIAS VOLATILE THREAD_LOCAL @@ -1096,10 +1089,11 @@ Module *llvm::RunVMAsmParser(const char * AsmString, Module * M) { %token EXTRACTELEMENT INSERTELEMENT SHUFFLEVECTOR // Function Attributes -%token NORETURN INREG SRET NOUNWIND +%token SIGNEXT ZEROEXT NORETURN INREG SRET NOUNWIND NOALIAS BYVAL NEST +%token READNONE READONLY GC // Visibility Styles -%token DEFAULT HIDDEN +%token DEFAULT HIDDEN PROTECTED %start Module %% @@ -1136,9 +1130,9 @@ FPredicates // These are some types that allow classification if we only want a particular // thing... for example, only a signed, unsigned, or integral type. IntType : INTTYPE; -FPType : FLOAT | DOUBLE; +FPType : FLOAT | DOUBLE | PPC_FP128 | FP128 | X86_FP80; -LocalName : LOCALVAR | STRINGCONSTANT; +LocalName : LOCALVAR | STRINGCONSTANT | PCTSTRINGCONSTANT ; OptLocalName : LocalName | /*empty*/ { $$ = 0; }; /// OptLocalAssign - Value producing statements have an optional assignment @@ -1152,7 +1146,7 @@ OptLocalAssign : LocalName '=' { CHECK_FOR_ERROR }; -GlobalName : GLOBALVAR | ATSTRINGCONSTANT; +GlobalName : GLOBALVAR | ATSTRINGCONSTANT ; OptGlobalAssign : GlobalAssign | /*empty*/ { @@ -1180,9 +1174,10 @@ GVExternalLinkage ; GVVisibilityStyle - : /*empty*/ { $$ = GlobalValue::DefaultVisibility; } - | DEFAULT { $$ = GlobalValue::DefaultVisibility; } - | HIDDEN { $$ = GlobalValue::HiddenVisibility; } + : /*empty*/ { $$ = GlobalValue::DefaultVisibility; } + | DEFAULT { $$ = GlobalValue::DefaultVisibility; } + | HIDDEN { $$ = GlobalValue::HiddenVisibility; } + | PROTECTED { $$ = GlobalValue::ProtectedVisibility; } ; FunctionDeclareLinkage @@ -1218,10 +1213,15 @@ OptCallingConv : /*empty*/ { $$ = CallingConv::C; } | CHECK_FOR_ERROR }; -ParamAttr : ZEXT { $$ = ParamAttr::ZExt; } - | SEXT { $$ = ParamAttr::SExt; } - | INREG { $$ = ParamAttr::InReg; } - | SRET { $$ = ParamAttr::StructRet; } +ParamAttr : ZEROEXT { $$ = ParamAttr::ZExt; } + | ZEXT { $$ = ParamAttr::ZExt; } + | SIGNEXT { $$ = ParamAttr::SExt; } + | SEXT { $$ = ParamAttr::SExt; } + | INREG { $$ = ParamAttr::InReg; } + | SRET { $$ = ParamAttr::StructRet; } + | NOALIAS { $$ = ParamAttr::NoAlias; } + | BYVAL { $$ = ParamAttr::ByVal; } + | NEST { $$ = ParamAttr::Nest; } ; OptParamAttrs : /* empty */ { $$ = ParamAttr::None; } @@ -1232,7 +1232,10 @@ OptParamAttrs : /* empty */ { $$ = ParamAttr::None; } FuncAttr : NORETURN { $$ = ParamAttr::NoReturn; } | NOUNWIND { $$ = ParamAttr::NoUnwind; } - | ParamAttr + | ZEROEXT { $$ = ParamAttr::ZExt; } + | SIGNEXT { $$ = ParamAttr::SExt; } + | READNONE { $$ = ParamAttr::ReadNone; } + | READONLY { $$ = ParamAttr::ReadOnly; } ; OptFuncAttrs : /* empty */ { $$ = ParamAttr::None; } @@ -1241,6 +1244,12 @@ OptFuncAttrs : /* empty */ { $$ = ParamAttr::None; } } ; +OptGC : /* empty */ { $$ = 0; } + | GC STRINGCONSTANT { + $$ = $2; + } + ; + // OptAlign/OptCAlign - An optional alignment, and an optional alignment with // a comma before it. OptAlign : /*empty*/ { $$ = 0; } | @@ -1260,8 +1269,8 @@ OptCAlign : /*empty*/ { $$ = 0; } | SectionString : SECTION STRINGCONSTANT { - for (unsigned i = 0, e = strlen($2); i != e; ++i) - if ($2[i] == '"' || $2[i] == '\\') + for (unsigned i = 0, e = $2->length(); i != e; ++i) + if ((*$2)[i] == '"' || (*$2)[i] == '\\') GEN_ERROR("Invalid character in section name"); $$ = $2; CHECK_FOR_ERROR @@ -1276,8 +1285,8 @@ OptSection : /*empty*/ { $$ = 0; } | GlobalVarAttributes : /* empty */ {} | ',' GlobalVarAttribute GlobalVarAttributes {}; GlobalVarAttribute : SectionString { - CurGV->setSection($1); - free($1); + CurGV->setSection(*$1); + delete $1; CHECK_FOR_ERROR } | ALIGN EUINT64VAL { @@ -1293,7 +1302,7 @@ GlobalVarAttribute : SectionString { // Derived types are added later... // -PrimType : INTTYPE | FLOAT | DOUBLE | LABEL ; +PrimType : INTTYPE | FLOAT | DOUBLE | PPC_FP128 | FP128 | X86_FP80 | LABEL ; Types : OPAQUE { @@ -1325,61 +1334,55 @@ Types CHECK_FOR_ERROR } | Types '(' ArgTypeListI ')' OptFuncAttrs { + // Allow but ignore attributes on function types; this permits auto-upgrade. + // FIXME: remove in LLVM 3.0. + const Type* RetTy = *$1; + if (!(RetTy->isFirstClassType() || RetTy == Type::VoidTy || + isa(RetTy))) + GEN_ERROR("LLVM Functions cannot return aggregates"); + std::vector Params; - ParamAttrsVector Attrs; - if ($5 != ParamAttr::None) { - ParamAttrsWithIndex X; X.index = 0; X.attrs = $5; - Attrs.push_back(X); - } - unsigned index = 1; TypeWithAttrsList::iterator I = $3->begin(), E = $3->end(); - for (; I != E; ++I, ++index) { + for (; I != E; ++I ) { const Type *Ty = I->Ty->get(); Params.push_back(Ty); - if (Ty != Type::VoidTy) - if (I->Attrs != ParamAttr::None) { - ParamAttrsWithIndex X; X.index = index; X.attrs = I->Attrs; - Attrs.push_back(X); - } } + bool isVarArg = Params.size() && Params.back() == Type::VoidTy; if (isVarArg) Params.pop_back(); - ParamAttrsList *ActualAttrs = 0; - if (!Attrs.empty()) - ActualAttrs = ParamAttrsList::get(Attrs); - FunctionType *FT = FunctionType::get(*$1, Params, isVarArg, ActualAttrs); + for (unsigned i = 0; i != Params.size(); ++i) + if (!(Params[i]->isFirstClassType() || isa(Params[i]))) + GEN_ERROR("Function arguments must be value types!"); + + CHECK_FOR_ERROR + + FunctionType *FT = FunctionType::get(RetTy, Params, isVarArg); delete $3; // Delete the argument list delete $1; // Delete the return type handle $$ = new PATypeHolder(HandleUpRefs(FT)); CHECK_FOR_ERROR } | VOID '(' ArgTypeListI ')' OptFuncAttrs { + // Allow but ignore attributes on function types; this permits auto-upgrade. + // FIXME: remove in LLVM 3.0. std::vector Params; - ParamAttrsVector Attrs; - if ($5 != ParamAttr::None) { - ParamAttrsWithIndex X; X.index = 0; X.attrs = $5; - Attrs.push_back(X); - } TypeWithAttrsList::iterator I = $3->begin(), E = $3->end(); - unsigned index = 1; - for ( ; I != E; ++I, ++index) { + for ( ; I != E; ++I ) { const Type* Ty = I->Ty->get(); Params.push_back(Ty); - if (Ty != Type::VoidTy) - if (I->Attrs != ParamAttr::None) { - ParamAttrsWithIndex X; X.index = index; X.attrs = I->Attrs; - Attrs.push_back(X); - } } + bool isVarArg = Params.size() && Params.back() == Type::VoidTy; if (isVarArg) Params.pop_back(); - ParamAttrsList *ActualAttrs = 0; - if (!Attrs.empty()) - ActualAttrs = ParamAttrsList::get(Attrs); + for (unsigned i = 0; i != Params.size(); ++i) + if (!(Params[i]->isFirstClassType() || isa(Params[i]))) + GEN_ERROR("Function arguments must be value types!"); - FunctionType *FT = FunctionType::get($1, Params, isVarArg, ActualAttrs); + CHECK_FOR_ERROR + + FunctionType *FT = FunctionType::get($1, Params, isVarArg); delete $3; // Delete the argument list $$ = new PATypeHolder(HandleUpRefs(FT)); CHECK_FOR_ERROR @@ -1396,8 +1399,6 @@ Types GEN_ERROR("Unsigned result not equal to signed result"); if (!ElemTy->isFloatingPoint() && !ElemTy->isInteger()) GEN_ERROR("Element type of a VectorType must be primitive"); - if (!isPowerOf2_32($2)) - GEN_ERROR("Vector length should be a power of 2"); $$ = new PATypeHolder(HandleUpRefs(VectorType::get(*$4, (unsigned)$2))); delete $4; CHECK_FOR_ERROR @@ -1433,9 +1434,11 @@ Types ; ArgType - : Types OptParamAttrs { + : Types OptParamAttrs { + // Allow but ignore attributes on function types; this permits auto-upgrade. + // FIXME: remove in LLVM 3.0. $$.Ty = $1; - $$.Attrs = $2; + $$.Attrs = ParamAttr::None; } ; @@ -1559,21 +1562,19 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr int NumElements = ATy->getNumElements(); const Type *ETy = ATy->getElementType(); - char *EndStr = UnEscapeLexed($3, true); - if (NumElements != -1 && NumElements != (EndStr-$3)) + if (NumElements != -1 && NumElements != int($3->length())) GEN_ERROR("Can't build string constant of size " + - itostr((int)(EndStr-$3)) + + itostr((int)($3->length())) + " when array has size " + itostr(NumElements) + ""); std::vector Vals; if (ETy == Type::Int8Ty) { - for (unsigned char *C = (unsigned char *)$3; - C != (unsigned char*)EndStr; ++C) - Vals.push_back(ConstantInt::get(ETy, *C)); + for (unsigned i = 0; i < $3->length(); ++i) + Vals.push_back(ConstantInt::get(ETy, (*$3)[i])); } else { - free($3); + delete $3; GEN_ERROR("Cannot build string arrays of non byte sized elements"); } - free($3); + delete $3; $$ = ConstantArray::get(ATy, Vals); delete $1; CHECK_FOR_ERROR @@ -1757,7 +1758,7 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr } else { std::string Name; if ($2.Type == ValID::GlobalName) - Name = $2.Name; + Name = $2.getName(); else if ($2.Type != ValID::GlobalID) GEN_ERROR("Invalid reference to global"); @@ -1845,10 +1846,15 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr $$ = ConstantInt::getFalse(); CHECK_FOR_ERROR } - | FPType FPVAL { // Float & Double constants - if (!ConstantFP::isValueValidForType($1, $2)) + | FPType FPVAL { // Floating point constants + if (!ConstantFP::isValueValidForType($1, *$2)) GEN_ERROR("Floating point constant invalid for type"); - $$ = ConstantFP::get($1, $2); + // Lexer has no type info, so builds all float and double FP constants + // as double. Fix this here. Long double is done right. + if (&$2->getSemantics()==&APFloat::IEEEdouble && $1==Type::FloatTy) + $2->convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven); + $$ = ConstantFP::get($1, *$2); + delete $2; CHECK_FOR_ERROR }; @@ -1870,7 +1876,7 @@ ConstExpr: CastOps '(' ConstVal TO Types ')' { GEN_ERROR("GetElementPtr requires a pointer operand"); const Type *IdxTy = - GetElementPtrInst::getIndexedType($3->getType(), &(*$4)[0], $4->size(), + GetElementPtrInst::getIndexedType($3->getType(), $4->begin(), $4->end(), true); if (!IdxTy) GEN_ERROR("Index list invalid for constant getelementptr"); @@ -1964,6 +1970,7 @@ ThreadLocal : THREAD_LOCAL { $$ = true; } | { $$ = false; }; AliaseeRef : ResultTypes SymbolicValueRef { const Type* VTy = $1->get(); Value *V = getVal(VTy, $2); + CHECK_FOR_ERROR GlobalValue* Aliasee = dyn_cast(V); if (!Aliasee) GEN_ERROR("Aliases can be created only to global values"); @@ -2087,18 +2094,43 @@ Definition CHECK_FOR_ERROR } | OptGlobalAssign GVVisibilityStyle ALIAS AliasLinkage AliaseeRef { - std::string Name($1); + std::string Name; + if ($1) { + Name = *$1; + delete $1; + } if (Name.empty()) GEN_ERROR("Alias name cannot be empty"); Constant* Aliasee = $5; if (Aliasee == 0) - GEN_ERROR(std::string("Invalid aliasee for alias: ") + $1); + GEN_ERROR(std::string("Invalid aliasee for alias: ") + Name); GlobalAlias* GA = new GlobalAlias(Aliasee->getType(), $4, Name, Aliasee, CurModule.CurrentModule); GA->setVisibility($2); InsertValue(GA, CurModule.Values); + + + // If there was a forward reference of this alias, resolve it now. + + ValID ID; + if (!Name.empty()) + ID = ValID::createGlobalName(Name); + else + ID = ValID::createGlobalID(CurModule.Values.size()-1); + + if (GlobalValue *FWGV = + CurModule.GetForwardRefForGlobal(GA->getType(), ID)) { + // Replace uses of the fwdref with the actual alias. + FWGV->replaceAllUsesWith(GA); + if (GlobalVariable *GV = dyn_cast(FWGV)) + GV->eraseFromParent(); + else + cast(FWGV)->eraseFromParent(); + } + ID.destroy(); + CHECK_FOR_ERROR } | TARGET TargetDefinition { @@ -2112,36 +2144,33 @@ Definition AsmBlock : STRINGCONSTANT { const std::string &AsmSoFar = CurModule.CurrentModule->getModuleInlineAsm(); - char *EndStr = UnEscapeLexed($1, true); - std::string NewAsm($1, EndStr); - free($1); - if (AsmSoFar.empty()) - CurModule.CurrentModule->setModuleInlineAsm(NewAsm); + CurModule.CurrentModule->setModuleInlineAsm(*$1); else - CurModule.CurrentModule->setModuleInlineAsm(AsmSoFar+"\n"+NewAsm); + CurModule.CurrentModule->setModuleInlineAsm(AsmSoFar+"\n"+*$1); + delete $1; CHECK_FOR_ERROR }; TargetDefinition : TRIPLE '=' STRINGCONSTANT { - CurModule.CurrentModule->setTargetTriple($3); - free($3); + CurModule.CurrentModule->setTargetTriple(*$3); + delete $3; } | DATALAYOUT '=' STRINGCONSTANT { - CurModule.CurrentModule->setDataLayout($3); - free($3); + CurModule.CurrentModule->setDataLayout(*$3); + delete $3; }; LibrariesDefinition : '[' LibList ']'; LibList : LibList ',' STRINGCONSTANT { - CurModule.CurrentModule->addLibrary($3); - free($3); + CurModule.CurrentModule->addLibrary(*$3); + delete $3; CHECK_FOR_ERROR } | STRINGCONSTANT { - CurModule.CurrentModule->addLibrary($1); - free($1); + CurModule.CurrentModule->addLibrary(*$1); + delete $1; CHECK_FOR_ERROR } | /* empty: end of list */ { @@ -2202,10 +2231,9 @@ ArgList : ArgListH { }; FunctionHeaderH : OptCallingConv ResultTypes GlobalName '(' ArgList ')' - OptFuncAttrs OptSection OptAlign { - UnEscapeLexed($3); - std::string FunctionName($3); - free($3); // Free strdup'd memory! + OptFuncAttrs OptSection OptAlign OptGC { + std::string FunctionName(*$3); + delete $3; // Free strdup'd memory! // Check the function result for abstractness if this is a define. We should // have no abstract types at this point @@ -2215,7 +2243,9 @@ FunctionHeaderH : OptCallingConv ResultTypes GlobalName '(' ArgList ')' std::vector ParamTypeList; ParamAttrsVector Attrs; if ($7 != ParamAttr::None) { - ParamAttrsWithIndex PAWI; PAWI.index = 0; PAWI.attrs = $7; + ParamAttrsWithIndex PAWI; + PAWI.index = 0; + PAWI.attrs = $7; Attrs.push_back(PAWI); } if ($5) { // If there are arguments... @@ -2227,7 +2257,9 @@ FunctionHeaderH : OptCallingConv ResultTypes GlobalName '(' ArgList ')' ParamTypeList.push_back(Ty); if (Ty != Type::VoidTy) if (I->Attrs != ParamAttr::None) { - ParamAttrsWithIndex PAWI; PAWI.index = index; PAWI.attrs = I->Attrs; + ParamAttrsWithIndex PAWI; + PAWI.index = index; + PAWI.attrs = I->Attrs; Attrs.push_back(PAWI); } } @@ -2236,11 +2268,11 @@ FunctionHeaderH : OptCallingConv ResultTypes GlobalName '(' ArgList ')' bool isVarArg = ParamTypeList.size() && ParamTypeList.back() == Type::VoidTy; if (isVarArg) ParamTypeList.pop_back(); - ParamAttrsList *PAL = 0; + const ParamAttrsList *PAL = 0; if (!Attrs.empty()) PAL = ParamAttrsList::get(Attrs); - FunctionType *FT = FunctionType::get(*$2, ParamTypeList, isVarArg, PAL); + FunctionType *FT = FunctionType::get(*$2, ParamTypeList, isVarArg); const PointerType *PFT = PointerType::get(FT); delete $2; @@ -2257,19 +2289,24 @@ FunctionHeaderH : OptCallingConv ResultTypes GlobalName '(' ArgList ')' // Move the function to the end of the list, from whereever it was // previously inserted. Fn = cast(FWRef); + assert(!Fn->getParamAttrs() && "Forward reference has parameter attributes!"); CurModule.CurrentModule->getFunctionList().remove(Fn); CurModule.CurrentModule->getFunctionList().push_back(Fn); } else if (!FunctionName.empty() && // Merge with an earlier prototype? (Fn = CurModule.CurrentModule->getFunction(FunctionName))) { - if (Fn->getFunctionType() != FT) { + if (Fn->getFunctionType() != FT ) { // The existing function doesn't have the same type. This is an overload // error. GEN_ERROR("Overload of function '" + FunctionName + "' not permitted."); + } else if (Fn->getParamAttrs() != PAL) { + // The existing function doesn't have the same parameter attributes. + // This is an overload error. + GEN_ERROR("Overload of function '" + FunctionName + "' not permitted."); } else if (!CurFun.isDeclare && !Fn->isDeclaration()) { // Neither the existing or the current function is a declaration and they // have the same name and same type. Clearly this is a redefinition. GEN_ERROR("Redefinition of function '" + FunctionName + "'"); - } if (Fn->isDeclaration()) { + } else if (Fn->isDeclaration()) { // Make sure to strip off any argument names so we can't get conflicts. for (Function::arg_iterator AI = Fn->arg_begin(), AE = Fn->arg_end(); AI != AE; ++AI) @@ -2278,7 +2315,6 @@ FunctionHeaderH : OptCallingConv ResultTypes GlobalName '(' ArgList ')' } else { // Not already defined? Fn = new Function(FT, GlobalValue::ExternalWeakLinkage, FunctionName, CurModule.CurrentModule); - InsertValue(Fn, CurModule.Values); } @@ -2292,10 +2328,15 @@ FunctionHeaderH : OptCallingConv ResultTypes GlobalName '(' ArgList ')' Fn->setVisibility(CurFun.Visibility); } Fn->setCallingConv($1); + Fn->setParamAttrs(PAL); Fn->setAlignment($9); if ($8) { - Fn->setSection($8); - free($8); + Fn->setSection(*$8); + delete $8; + } + if ($10) { + Fn->setCollector($10->c_str()); + delete $10; } // Add all of the arguments we parsed to the function... @@ -2312,7 +2353,7 @@ FunctionHeaderH : OptCallingConv ResultTypes GlobalName '(' ArgList ')' for (ArgListType::iterator I = $5->begin(); I != $5->end() && ArgIt != ArgEnd; ++I, ++ArgIt) { delete I->Ty; // Delete the typeholder... - setValueName(ArgIt, I->Name); // Insert arg into symtab... + setValueName(ArgIt, I->Name); // Insert arg into symtab... CHECK_FOR_ERROR InsertValue(ArgIt); Idx++; @@ -2424,13 +2465,9 @@ ConstValueRef : ESINT64VAL { // A reference to a direct constant CHECK_FOR_ERROR } | 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); + $$ = ValID::createInlineAsm(*$3, *$5, $2); + delete $3; + delete $5; CHECK_FOR_ERROR }; @@ -2446,11 +2483,13 @@ SymbolicValueRef : LOCALVAL_ID { // Is it an integer reference...? CHECK_FOR_ERROR } | LocalName { // Is it a named reference...? - $$ = ValID::createLocalName($1); + $$ = ValID::createLocalName(*$1); + delete $1; CHECK_FOR_ERROR } | GlobalName { // Is it a named reference...? - $$ = ValID::createGlobalName($1); + $$ = ValID::createGlobalName(*$1); + delete $1; CHECK_FOR_ERROR }; @@ -2506,8 +2545,10 @@ InstructionList : InstructionList Inst { CHECK_FOR_ERROR } | LABELSTR { // Labelled (named) basic block - $$ = defineBBVal(ValID::createLocalName($1)); + $$ = defineBBVal(ValID::createLocalName(*$1)); + delete $1; CHECK_FOR_ERROR + }; BBTerminatorInst : RET ResolvedVal { // Return with a result... @@ -2561,7 +2602,7 @@ BBTerminatorInst : RET ResolvedVal { // Return with a result... $$ = S; CHECK_FOR_ERROR } - | INVOKE OptCallingConv ResultTypes ValueRef '(' ValueRefList ')' OptFuncAttrs + | INVOKE OptCallingConv ResultTypes ValueRef '(' ParamList ')' OptFuncAttrs TO LABEL ValueRef UNWIND LABEL ValueRef { // Handle the short syntax @@ -2571,28 +2612,14 @@ BBTerminatorInst : RET ResolvedVal { // Return with a result... !(Ty = dyn_cast(PFTy->getElementType()))) { // Pull out the types of all of the arguments... std::vector ParamTypes; - ParamAttrsVector Attrs; - if ($8 != ParamAttr::None) { - ParamAttrsWithIndex PAWI; PAWI.index = 0; PAWI.attrs = 8; - Attrs.push_back(PAWI); - } - ValueRefList::iterator I = $6->begin(), E = $6->end(); - unsigned index = 1; - for (; I != E; ++I, ++index) { + ParamList::iterator I = $6->begin(), E = $6->end(); + for (; I != E; ++I) { const Type *Ty = I->Val->getType(); if (Ty == Type::VoidTy) GEN_ERROR("Short call syntax cannot be used with varargs"); ParamTypes.push_back(Ty); - if (I->Attrs != ParamAttr::None) { - ParamAttrsWithIndex PAWI; PAWI.index = index; PAWI.attrs = I->Attrs; - Attrs.push_back(PAWI); - } } - - ParamAttrsList *PAL = 0; - if (!Attrs.empty()) - PAL = ParamAttrsList::get(Attrs); - Ty = FunctionType::get($3->get(), ParamTypes, false, PAL); + Ty = FunctionType::get($3->get(), ParamTypes, false); PFTy = PointerType::get(Ty); } @@ -2605,6 +2632,12 @@ BBTerminatorInst : RET ResolvedVal { // Return with a result... BasicBlock *Except = getBBVal($14); CHECK_FOR_ERROR + ParamAttrsVector Attrs; + if ($8 != ParamAttr::None) { + ParamAttrsWithIndex PAWI; PAWI.index = 0; PAWI.attrs = $8; + Attrs.push_back(PAWI); + } + // Check the arguments ValueList Args; if ($6->empty()) { // Has no arguments? @@ -2617,13 +2650,20 @@ BBTerminatorInst : RET ResolvedVal { // Return with a result... // correctly! FunctionType::param_iterator I = Ty->param_begin(); FunctionType::param_iterator E = Ty->param_end(); - ValueRefList::iterator ArgI = $6->begin(), ArgE = $6->end(); + ParamList::iterator ArgI = $6->begin(), ArgE = $6->end(); + unsigned index = 1; - for (; ArgI != ArgE && I != E; ++ArgI, ++I) { + for (; ArgI != ArgE && I != E; ++ArgI, ++I, ++index) { if (ArgI->Val->getType() != *I) GEN_ERROR("Parameter " + ArgI->Val->getName()+ " is not of type '" + (*I)->getDescription() + "'"); Args.push_back(ArgI->Val); + if (ArgI->Attrs != ParamAttr::None) { + ParamAttrsWithIndex PAWI; + PAWI.index = index; + PAWI.attrs = ArgI->Attrs; + Attrs.push_back(PAWI); + } } if (Ty->isVarArg()) { @@ -2634,9 +2674,14 @@ BBTerminatorInst : RET ResolvedVal { // Return with a result... GEN_ERROR("Invalid number of parameters detected"); } + const ParamAttrsList *PAL = 0; + if (!Attrs.empty()) + PAL = ParamAttrsList::get(Attrs); + // Create the InvokeInst - InvokeInst *II = new InvokeInst(V, Normal, Except, &Args[0], Args.size()); + InvokeInst *II = new InvokeInst(V, Normal, Except, Args.begin(), Args.end()); II->setCallingConv($2); + II->setParamAttrs(PAL); $$ = II; delete $6; CHECK_FOR_ERROR @@ -2707,25 +2752,43 @@ PHIList : Types '[' ValueRef ',' ValueRef ']' { // Used for PHI nodes }; -ValueRefList : Types ValueRef OptParamAttrs { +ParamList : Types OptParamAttrs ValueRef OptParamAttrs { + // FIXME: Remove trailing OptParamAttrs in LLVM 3.0, it was a mistake in 2.0 if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription()); // Used for call and invoke instructions - $$ = new ValueRefList(); - ValueRefListEntry E; E.Attrs = $3; E.Val = getVal($1->get(), $2); + $$ = new ParamList(); + ParamListEntry E; E.Attrs = $2 | $4; E.Val = getVal($1->get(), $3); $$->push_back(E); delete $1; + CHECK_FOR_ERROR } - | ValueRefList ',' Types ValueRef OptParamAttrs { + | LABEL OptParamAttrs ValueRef OptParamAttrs { + // FIXME: Remove trailing OptParamAttrs in LLVM 3.0, it was a mistake in 2.0 + // Labels are only valid in ASMs + $$ = new ParamList(); + ParamListEntry E; E.Attrs = $2 | $4; E.Val = getBBVal($3); + $$->push_back(E); + CHECK_FOR_ERROR + } + | ParamList ',' Types OptParamAttrs ValueRef OptParamAttrs { + // FIXME: Remove trailing OptParamAttrs in LLVM 3.0, it was a mistake in 2.0 if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*$3)->getDescription()); $$ = $1; - ValueRefListEntry E; E.Attrs = $5; E.Val = getVal($3->get(), $4); + ParamListEntry E; E.Attrs = $4 | $6; E.Val = getVal($3->get(), $5); $$->push_back(E); delete $3; CHECK_FOR_ERROR } - | /*empty*/ { $$ = new ValueRefList(); }; + | ParamList ',' LABEL OptParamAttrs ValueRef OptParamAttrs { + // FIXME: Remove trailing OptParamAttrs in LLVM 3.0, it was a mistake in 2.0 + $$ = $1; + ParamListEntry E; E.Attrs = $4 | $6; E.Val = getBBVal($5); + $$->push_back(E); + CHECK_FOR_ERROR + } + | /*empty*/ { $$ = new ParamList(); }; IndexList // Used for gep instructions and constant expressions : /*empty*/ { $$ = new std::vector(); } @@ -2752,11 +2815,6 @@ InstVal : ArithmeticOps Types ValueRef ',' ValueRef { !isa((*$2).get())) GEN_ERROR( "Arithmetic operator requires integer, FP, or packed operands"); - if (isa((*$2).get()) && - ($1 == Instruction::URem || - $1 == Instruction::SRem || - $1 == Instruction::FRem)) - GEN_ERROR("Remainder not supported on vector types"); Value* val1 = getVal(*$2, $3); CHECK_FOR_ERROR Value* val2 = getVal(*$2, $5); @@ -2871,7 +2929,7 @@ InstVal : ArithmeticOps Types ValueRef ',' ValueRef { delete $2; // Free the list... CHECK_FOR_ERROR } - | OptTailCall OptCallingConv ResultTypes ValueRef '(' ValueRefList ')' + | OptTailCall OptCallingConv ResultTypes ValueRef '(' ParamList ')' OptFuncAttrs { // Handle the short syntax @@ -2881,29 +2939,14 @@ InstVal : ArithmeticOps Types ValueRef ',' ValueRef { !(Ty = dyn_cast(PFTy->getElementType()))) { // Pull out the types of all of the arguments... std::vector ParamTypes; - ParamAttrsVector Attrs; - if ($8 != ParamAttr::None) { - ParamAttrsWithIndex PAWI; PAWI.index = 0; PAWI.attrs = $8; - Attrs.push_back(PAWI); - } - unsigned index = 1; - ValueRefList::iterator I = $6->begin(), E = $6->end(); - for (; I != E; ++I, ++index) { + ParamList::iterator I = $6->begin(), E = $6->end(); + for (; I != E; ++I) { const Type *Ty = I->Val->getType(); if (Ty == Type::VoidTy) GEN_ERROR("Short call syntax cannot be used with varargs"); ParamTypes.push_back(Ty); - if (I->Attrs != ParamAttr::None) { - ParamAttrsWithIndex PAWI; PAWI.index = index; PAWI.attrs = I->Attrs; - Attrs.push_back(PAWI); - } } - - ParamAttrsList *PAL = 0; - if (!Attrs.empty()) - PAL = ParamAttrsList::get(Attrs); - - Ty = FunctionType::get($3->get(), ParamTypes, false, PAL); + Ty = FunctionType::get($3->get(), ParamTypes, false); PFTy = PointerType::get(Ty); } @@ -2919,6 +2962,14 @@ InstVal : ArithmeticOps Types ValueRef ',' ValueRef { theF->getName() + "'"); } + // Set up the ParamAttrs for the function + ParamAttrsVector Attrs; + if ($8 != ParamAttr::None) { + ParamAttrsWithIndex PAWI; + PAWI.index = 0; + PAWI.attrs = $8; + Attrs.push_back(PAWI); + } // Check the arguments ValueList Args; if ($6->empty()) { // Has no arguments? @@ -2928,17 +2979,23 @@ InstVal : ArithmeticOps Types ValueRef ',' ValueRef { "expects arguments"); } else { // Has arguments? // Loop through FunctionType's arguments and ensure they are specified - // correctly! - // + // correctly. Also, gather any parameter attributes. FunctionType::param_iterator I = Ty->param_begin(); FunctionType::param_iterator E = Ty->param_end(); - ValueRefList::iterator ArgI = $6->begin(), ArgE = $6->end(); + ParamList::iterator ArgI = $6->begin(), ArgE = $6->end(); + unsigned index = 1; - for (; ArgI != ArgE && I != E; ++ArgI, ++I) { + for (; ArgI != ArgE && I != E; ++ArgI, ++I, ++index) { if (ArgI->Val->getType() != *I) GEN_ERROR("Parameter " + ArgI->Val->getName()+ " is not of type '" + (*I)->getDescription() + "'"); Args.push_back(ArgI->Val); + if (ArgI->Attrs != ParamAttr::None) { + ParamAttrsWithIndex PAWI; + PAWI.index = index; + PAWI.attrs = ArgI->Attrs; + Attrs.push_back(PAWI); + } } if (Ty->isVarArg()) { if (I == E) @@ -2947,10 +3004,17 @@ InstVal : ArithmeticOps Types ValueRef ',' ValueRef { } else if (I != E || ArgI != ArgE) GEN_ERROR("Invalid number of parameters detected"); } + + // Finish off the ParamAttrs and check them + const ParamAttrsList *PAL = 0; + if (!Attrs.empty()) + PAL = ParamAttrsList::get(Attrs); + // Create the call node - CallInst *CI = new CallInst(V, &Args[0], Args.size()); + CallInst *CI = new CallInst(V, Args.begin(), Args.end()); CI->setTailCall($1); CI->setCallingConv($2); + CI->setParamAttrs(PAL); $$ = CI; delete $6; delete $3; @@ -3047,12 +3111,12 @@ MemoryInst : MALLOC Types OptCAlign { if (!isa($2->get())) GEN_ERROR("getelementptr insn requires pointer operand"); - if (!GetElementPtrInst::getIndexedType(*$2, &(*$4)[0], $4->size(), true)) + if (!GetElementPtrInst::getIndexedType(*$2, $4->begin(), $4->end(), true)) GEN_ERROR("Invalid getelementptr indices for type '" + (*$2)->getDescription()+ "'"); Value* tmpVal = getVal(*$2, $3); CHECK_FOR_ERROR - $$ = new GetElementPtrInst(tmpVal, &(*$4)[0], $4->size()); + $$ = new GetElementPtrInst(tmpVal, $4->begin(), $4->end()); delete $2; delete $4; }; @@ -3062,13 +3126,7 @@ MemoryInst : MALLOC Types OptCAlign { // common code from the two 'RunVMAsmParser' functions static Module* RunParser(Module * M) { - - llvmAsmlineno = 1; // Reset the current line number... CurModule.CurrentModule = M; -#if YYDEBUG - yydebug = Debug; -#endif - // Check to make sure the parser succeeded if (yyparse()) { if (ParserResult) @@ -3120,21 +3178,21 @@ static Module* RunParser(Module * M) { } void llvm::GenerateError(const std::string &message, int LineNo) { - if (LineNo == -1) LineNo = llvmAsmlineno; + if (LineNo == -1) LineNo = LLLgetLineNo(); // TODO: column number in exception if (TheParseError) - TheParseError->setError(CurFilename, message, LineNo); + TheParseError->setError(LLLgetFilename(), message, LineNo); TriggerError = 1; } int yyerror(const char *ErrorMsg) { - std::string where - = std::string((CurFilename == "-") ? std::string("") : CurFilename) - + ":" + utostr((unsigned) llvmAsmlineno) + ": "; + std::string where = LLLgetFilename() + ":" + utostr(LLLgetLineNo()) + ": "; std::string errMsg = where + "error: " + std::string(ErrorMsg); - if (yychar != YYEMPTY && yychar != 0) - errMsg += " while reading token: '" + std::string(llvmAsmtext, llvmAsmleng)+ - "'"; + if (yychar != YYEMPTY && yychar != 0) { + errMsg += " while reading token: '"; + errMsg += std::string(LLLgetTokenStart(), + LLLgetTokenStart()+LLLgetTokenLength()) + "'"; + } GenerateError(errMsg); return 0; }