//===-- llvmAsmParser.y - Parser for llvm assembly files --------*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file implements the bison parser for LLVM assembly languages files.
%{
#include "ParserInternals.h"
-#include "llvm/SymbolTable.h"
+#include "llvm/CallingConv.h"
+#include "llvm/InlineAsm.h"
+#include "llvm/Instructions.h"
#include "llvm/Module.h"
-#include "llvm/iTerminators.h"
-#include "llvm/iMemory.h"
-#include "llvm/iOperators.h"
-#include "llvm/iPHINode.h"
+#include "llvm/SymbolTable.h"
+#include "llvm/Assembly/AutoUpgrade.h"
#include "llvm/Support/GetElementPtrTypeIterator.h"
-#include "Support/STLExtras.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/MathExtras.h"
#include <algorithm>
#include <iostream>
#include <list>
#define YYERROR_VERBOSE 1
-// HACK ALERT: This variable is used to implement the automatic conversion of
-// variable argument instructions from their old to new forms. When this
-// compatiblity "Feature" is removed, this should be too.
-//
-static BasicBlock *CurBB;
static bool ObsoleteVarArgs;
+static bool NewVarArgs;
+static BasicBlock *CurBB;
+static GlobalVariable *CurGV;
// This contains info used when building the body of a function. It is
// destroyed when the function is completed.
//
typedef std::vector<Value *> ValueList; // Numbered defs
-static void ResolveDefinitions(std::map<const Type *,ValueList> &LateResolvers,
- std::map<const Type *,ValueList> *FutureLateResolvers = 0);
+static void
+ResolveDefinitions(std::map<const Type *,ValueList> &LateResolvers,
+ std::map<const Type *,ValueList> *FutureLateResolvers = 0);
static struct PerModuleInfo {
Module *CurrentModule;
std::map<ValID, PATypeHolder> LateResolveTypes;
/// PlaceHolderInfo - When temporary placeholder objects are created, remember
- /// how they were referenced and one which line of the input they came from so
+ /// how they were referenced and on which line of the input they came from so
/// that we can resolve them later and print error messages as appropriate.
std::map<Value*, std::pair<ValID, int> > PlaceHolderInfo;
//
if (!GlobalRefs.empty()) {
std::string UndefinedReferences = "Unresolved global references exist:\n";
-
+
for (GlobalRefsType::iterator I = GlobalRefs.begin(), E =GlobalRefs.end();
I != E; ++I) {
UndefinedReferences += " " + I->first.first->getDescription() + " " +
ThrowException(UndefinedReferences);
}
+ // Look for intrinsic functions and CallInst that need to be upgraded
+ for (Module::iterator FI = CurrentModule->begin(),
+ FE = CurrentModule->end(); FI != FE; )
+ UpgradeCallsToIntrinsic(FI++);
+
Values.clear(); // Clear out function local definitions
Types.clear();
CurrentModule = 0;
}
-
// GetForwardRefForGlobal - Check to see if there is a forward reference
// for this global. If so, remove it from the GlobalRefs map and return it.
// If not, just return null.
std::map<const Type*, ValueList> Values; // Keep track of #'d definitions
std::map<const Type*, ValueList> LateResolveValues;
- std::vector<PATypeHolder> Types;
- std::map<ValID, PATypeHolder> LateResolveTypes;
bool isDeclare; // Is this function a forward declararation?
/// BBForwardRefs - When we see forward references to basic blocks, keep
// Any forward referenced blocks left?
if (!BBForwardRefs.empty())
ThrowException("Undefined reference to label " +
- BBForwardRefs.begin()->second.first.getName());
+ BBForwardRefs.begin()->first->getName());
// Resolve all forward references now.
ResolveDefinitions(LateResolveValues, &CurModule.LateResolveValues);
Values.clear(); // Clear out function local definitions
- Types.clear(); // Clear out function local types
CurrentFunction = 0;
isDeclare = false;
}
switch (D.Type) {
case ValID::NumberVal: // Is it a numbered definition?
// Module constants occupy the lowest numbered slots...
- if ((unsigned)D.Num < CurModule.Types.size())
+ if ((unsigned)D.Num < CurModule.Types.size())
return CurModule.Types[(unsigned)D.Num];
break;
case ValID::NameVal: // Is it a named definition?
//
if (DoNotImprovise) return 0; // Do we just want a null to be returned?
- std::map<ValID, PATypeHolder> &LateResolver = inFunctionScope() ?
- CurFun.LateResolveTypes : CurModule.LateResolveTypes;
-
- std::map<ValID, PATypeHolder>::iterator I = LateResolver.find(D);
- if (I != LateResolver.end()) {
- return I->second;
+
+ if (inFunctionScope()) {
+ if (D.Type == ValID::NameVal)
+ ThrowException("Reference to an undefined type: '" + D.getName() + "'");
+ else
+ ThrowException("Reference to an undefined type: #" + itostr(D.Num));
}
+ std::map<ValID, PATypeHolder>::iterator I =CurModule.LateResolveTypes.find(D);
+ if (I != CurModule.LateResolveTypes.end())
+ return I->second;
+
Type *Typ = OpaqueType::get();
- LateResolver.insert(std::make_pair(D, Typ));
+ CurModule.LateResolveTypes.insert(std::make_pair(D, Typ));
return Typ;
-}
+ }
static Value *lookupInSymbolTable(const Type *Ty, const std::string &Name) {
- SymbolTable &SymTab =
+ SymbolTable &SymTab =
inFunctionScope() ? CurFun.CurrentFunction->getSymbolTable() :
CurModule.CurrentModule->getSymbolTable();
return SymTab.lookup(Ty, Name);
// Module constants occupy the lowest numbered slots...
std::map<const Type*,ValueList>::iterator VI = CurModule.Values.find(Ty);
if (VI != CurModule.Values.end()) {
- if (Num < VI->second.size())
+ if (Num < VI->second.size())
return VI->second[Num];
Num -= VI->second.size();
}
// Check that the number is within bounds...
if (VI->second.size() <= Num) return 0;
-
+
return VI->second[Num];
}
return N;
}
- // Check to make sure that "Ty" is an integral type, and that our
+ // Check to make sure that "Ty" is an integral type, and that our
// value will fit into the specified type...
case ValID::ConstSIntVal: // Is it a constant pool reference??
if (!ConstantSInt::isValueValidForType(Ty, D.ConstPool64))
ThrowException("Signed integral constant '" +
- itostr(D.ConstPool64) + "' is invalid for type '" +
+ itostr(D.ConstPool64) + "' is invalid for type '" +
Ty->getDescription() + "'!");
return ConstantSInt::get(Ty, D.ConstPool64);
if (!ConstantFP::isValueValidForType(Ty, D.ConstPoolFP))
ThrowException("FP constant invalid for type!!");
return ConstantFP::get(Ty, D.ConstPoolFP);
-
+
case ValID::ConstNullVal: // Is it a null value?
if (!isa<PointerType>(Ty))
ThrowException("Cannot create a a non pointer null!");
return ConstantPointerNull::get(cast<PointerType>(Ty));
+
+ case ValID::ConstUndefVal: // Is it an undef value?
+ return UndefValue::get(Ty);
+
+ case ValID::ConstZeroVal: // Is it a zero value?
+ return Constant::getNullValue(Ty);
case ValID::ConstantVal: // Fully resolved constant?
if (D.ConstantValue->getType() != Ty)
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;
Value *V = getValNonImprovising(Ty, ID);
if (V) return V;
+ if (!Ty->isFirstClassType() && !isa<OpaqueType>(Ty))
+ ThrowException("Invalid use of a composite type!");
+
// If we reached here, we referenced either a symbol that we don't know about
// or an id number that hasn't been read yet. We may be referencing something
// forward, so just create an entry to be resolved later and get to it...
if (inFunctionScope())
InsertValue(V, CurFun.LateResolveValues);
- else
+ else
InsertValue(V, CurModule.LateResolveValues);
return V;
}
CurFun.CurrentFunction->getBasicBlockList().remove(BB);
CurFun.CurrentFunction->getBasicBlockList().push_back(BB);
}
-
+ ID.destroy();
return BB;
}
// and back patchs after we are done.
//
-// ResolveDefinitions - If we could not resolve some defs at parsing
-// time (forward branches, phi functions for loops, etc...) resolve the
+// ResolveDefinitions - If we could not resolve some defs at parsing
+// time (forward branches, phi functions for loops, etc...) resolve the
// defs now...
//
-static void ResolveDefinitions(std::map<const Type*,ValueList> &LateResolvers,
- std::map<const Type*,ValueList> *FutureLateResolvers) {
+static void
+ResolveDefinitions(std::map<const Type*,ValueList> &LateResolvers,
+ std::map<const Type*,ValueList> *FutureLateResolvers) {
// Loop over LateResolveDefs fixing up stuff that couldn't be resolved
for (std::map<const Type*,ValueList>::iterator LRI = LateResolvers.begin(),
E = LateResolvers.end(); LRI != E; ++LRI) {
PHI->second.second);
else
ThrowException("Reference to an invalid definition: #" +
- itostr(DID.Num) + " of type '" +
+ itostr(DID.Num) + " of type '" +
V->getType()->getDescription() + "'",
PHI->second.second);
}
// refering to the number can be resolved. Do this now.
//
static void ResolveTypeTo(char *Name, const Type *ToTy) {
- std::vector<PATypeHolder> &Types = inFunctionScope() ?
- CurFun.Types : CurModule.Types;
-
- ValID D;
- if (Name) D = ValID::create(Name);
- else D = ValID::create((int)Types.size());
-
- std::map<ValID, PATypeHolder> &LateResolver = inFunctionScope() ?
- CurFun.LateResolveTypes : CurModule.LateResolveTypes;
-
- std::map<ValID, PATypeHolder>::iterator I = LateResolver.find(D);
- if (I != LateResolver.end()) {
- ((DerivedType*)I->second.get())->refineAbstractTypeTo(ToTy);
- LateResolver.erase(I);
- }
-}
-
-// ResolveTypes - At this point, all types should be resolved. Any that aren't
-// are errors.
-//
-static void ResolveTypes(std::map<ValID, PATypeHolder> &LateResolveTypes) {
- if (!LateResolveTypes.empty()) {
- const ValID &DID = LateResolveTypes.begin()->first;
+ ValID D;
+ if (Name) D = ValID::create(Name);
+ else D = ValID::create((int)CurModule.Types.size());
- if (DID.Type == ValID::NameVal)
- ThrowException("Reference to an invalid type: '" +DID.getName() + "'");
- else
- ThrowException("Reference to an invalid type: #" + itostr(DID.Num));
+ std::map<ValID, PATypeHolder>::iterator I =
+ CurModule.LateResolveTypes.find(D);
+ if (I != CurModule.LateResolveTypes.end()) {
+ ((DerivedType*)I->second.get())->refineAbstractTypeTo(ToTy);
+ CurModule.LateResolveTypes.erase(I);
}
}
std::string Name(NameStr); // Copy string
free(NameStr); // Free old string
- if (V->getType() == Type::VoidTy)
+ if (V->getType() == Type::VoidTy)
ThrowException("Can't assign name '" + Name+"' to value with void type!");
-
+
assert(inFunctionScope() && "Must be in function scope!");
SymbolTable &ST = CurFun.CurrentFunction->getSymbolTable();
if (ST.lookup(V->getType(), Name))
ThrowException("Redefinition of value named '" + Name + "' in the '" +
V->getType()->getDescription() + "' type plane!");
-
+
// Set the name.
- V->setName(Name, &ST);
+ V->setName(Name);
}
}
/// ParseGlobalVariable - Handle parsing of a global. If Initializer is null,
/// this is a declaration, otherwise it is a definition.
-static void ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage,
- bool isConstantGlobal, const Type *Ty,
- Constant *Initializer) {
+static GlobalVariable *
+ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage,
+ bool isConstantGlobal, const Type *Ty,
+ Constant *Initializer) {
if (isa<FunctionType>(Ty))
ThrowException("Cannot declare global vars of function type!");
- const PointerType *PTy = PointerType::get(Ty);
+ const PointerType *PTy = PointerType::get(Ty);
std::string Name;
if (NameStr) {
// See if this global value was forward referenced. If so, recycle the
// object.
- ValID ID;
+ ValID ID;
if (!Name.empty()) {
ID = ValID::create((char*)Name.c_str());
} else {
}
if (GlobalValue *FWGV = CurModule.GetForwardRefForGlobal(PTy, ID)) {
- // Move the global to the end of the list, from whereever it was
+ // Move the global to the end of the list, from whereever it was
// previously inserted.
GlobalVariable *GV = cast<GlobalVariable>(FWGV);
CurModule.CurrentModule->getGlobalList().remove(GV);
GV->setLinkage(Linkage);
GV->setConstant(isConstantGlobal);
InsertValue(GV, CurModule.Values);
- return;
+ return GV;
}
// If this global has a name, check to see if there is already a definition
if (!Name.empty()) {
// We are a simple redefinition of a value, check to see if it is defined
// the same as the old one.
- if (GlobalVariable *EGV =
+ if (GlobalVariable *EGV =
CurModule.CurrentModule->getGlobalVariable(Name, Ty)) {
// We are allowed to redefine a global variable in two circumstances:
- // 1. If at least one of the globals is uninitialized or
+ // 1. If at least one of the globals is uninitialized or
// 2. If both initializers have the same value.
//
if (!EGV->hasInitializer() || !Initializer ||
if (isConstantGlobal)
EGV->setConstant(true);
EGV->setLinkage(Linkage);
- return;
+ return EGV;
}
- ThrowException("Redefinition of global variable named '" + Name +
+ ThrowException("Redefinition of global variable named '" + Name +
"' in the '" + Ty->getDescription() + "' type plane!");
}
}
// Otherwise there is no existing GV to use, create one now.
GlobalVariable *GV =
- new GlobalVariable(Ty, isConstantGlobal, Linkage, Initializer, Name,
+ new GlobalVariable(Ty, isConstantGlobal, Linkage, Initializer, Name,
CurModule.CurrentModule);
InsertValue(GV, CurModule.Values);
+ return GV;
}
// setTypeName - Set the specified type to the name given. The name may be
static bool setTypeName(const Type *T, char *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
// We don't allow assigning names to void type
- if (T == Type::VoidTy)
+ if (T == Type::VoidTy)
ThrowException("Can't assign name '" + Name + "' to the void type!");
// Set the type name, checking for conflicts as we do so.
// TypeContains - Returns true if Ty directly contains E in it.
//
static bool TypeContains(const Type *Ty, const Type *E) {
- return find(Ty->subtype_begin(), Ty->subtype_end(), E) != Ty->subtype_end();
+ return std::find(Ty->subtype_begin(), Ty->subtype_end(),
+ E) != Ty->subtype_end();
}
namespace {
// NestingLevel - The number of nesting levels that need to be popped before
// this type is resolved.
unsigned NestingLevel;
-
+
// LastContainedTy - This is the type at the current binding level for the
// type. Every time we reduce the nesting level, this gets updated.
const Type *LastContainedTy;
static PATypeHolder HandleUpRefs(const Type *ty) {
if (!ty->isAbstract()) return ty;
PATypeHolder Ty(ty);
- UR_OUT("Type '" << Ty->getDescription() <<
+ UR_OUT("Type '" << Ty->getDescription() <<
"' newly formed. Resolving upreferences.\n" <<
UpRefs.size() << " upreferences active!\n");
OpaqueType *TypeToResolve = 0;
for (unsigned i = 0; i != UpRefs.size(); ++i) {
- UR_OUT(" UR#" << i << " - TypeContains(" << Ty->getDescription() << ", "
- << UpRefs[i].second->getDescription() << ") = "
+ UR_OUT(" UR#" << i << " - TypeContains(" << Ty->getDescription() << ", "
+ << UpRefs[i].second->getDescription() << ") = "
<< (TypeContains(Ty, UpRefs[i].second) ? "true" : "false") << "\n");
if (TypeContains(Ty, UpRefs[i].LastContainedTy)) {
// Decrement level of upreference
unsigned Level = --UpRefs[i].NestingLevel;
UpRefs[i].LastContainedTy = Ty;
UR_OUT(" Uplevel Ref Level = " << Level << "\n");
- if (Level == 0) { // Upreference should be resolved!
+ if (Level == 0) { // Upreference should be resolved!
if (!TypeToResolve) {
TypeToResolve = UpRefs[i].UpRefTy;
} else {
}
-//===----------------------------------------------------------------------===//
-// RunVMAsmParser - Define an interface to this parser
-//===----------------------------------------------------------------------===//
-//
-Module *llvm::RunVMAsmParser(const std::string &Filename, FILE *F) {
- llvmAsmin = F;
- CurFilename = Filename;
+// common code from the two 'RunVMAsmParser' functions
+ static Module * RunParser(Module * M) {
+
llvmAsmlineno = 1; // Reset the current line number...
ObsoleteVarArgs = false;
+ NewVarArgs = false;
- // Allocate a new module to read
- CurModule.CurrentModule = new Module(Filename);
-
+ CurModule.CurrentModule = M;
yyparse(); // Parse the file, potentially throwing exception
Module *Result = ParserResult;
+ ParserResult = 0;
- // Check to see if they called va_start but not va_arg..
- if (!ObsoleteVarArgs)
- if (Function *F = Result->getNamedFunction("llvm.va_start"))
- if (F->asize() == 1) {
- std::cerr << "WARNING: this file uses obsolete features. "
- << "Assemble and disassemble to update it.\n";
- ObsoleteVarArgs = true;
- }
+ //Not all functions use vaarg, so make a second check for ObsoleteVarArgs
+ {
+ Function* F;
+ if ((F = Result->getNamedFunction("llvm.va_start"))
+ && F->getFunctionType()->getNumParams() == 0)
+ ObsoleteVarArgs = true;
+ if((F = Result->getNamedFunction("llvm.va_copy"))
+ && F->getFunctionType()->getNumParams() == 1)
+ ObsoleteVarArgs = true;
+ }
- if (ObsoleteVarArgs) {
- // If the user is making use of obsolete varargs intrinsics, adjust them for
- // the user.
- if (Function *F = Result->getNamedFunction("llvm.va_start")) {
- assert(F->asize() == 1 && "Obsolete va_start takes 1 argument!");
+ if (ObsoleteVarArgs && NewVarArgs)
+ ThrowException("This file is corrupt: it uses both new and old style varargs");
- const Type *RetTy = F->getFunctionType()->getParamType(0);
- RetTy = cast<PointerType>(RetTy)->getElementType();
- Function *NF = Result->getOrInsertFunction("llvm.va_start", RetTy, 0);
+ if(ObsoleteVarArgs) {
+ if(Function* F = Result->getNamedFunction("llvm.va_start")) {
+ if (F->arg_size() != 0)
+ ThrowException("Obsolete va_start takes 0 argument!");
+ //foo = va_start()
+ // ->
+ //bar = alloca typeof(foo)
+ //va_start(bar)
+ //foo = load bar
+
+ const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
+ const Type* ArgTy = F->getFunctionType()->getReturnType();
+ const Type* ArgTyPtr = PointerType::get(ArgTy);
+ Function* NF = Result->getOrInsertFunction("llvm.va_start",
+ RetTy, ArgTyPtr, (Type *)0);
+
while (!F->use_empty()) {
- CallInst *CI = cast<CallInst>(F->use_back());
- Value *V = new CallInst(NF, "", CI);
- new StoreInst(V, CI->getOperand(1), CI);
+ CallInst* CI = cast<CallInst>(F->use_back());
+ AllocaInst* bar = new AllocaInst(ArgTy, 0, "vastart.fix.1", CI);
+ new CallInst(NF, bar, "", CI);
+ Value* foo = new LoadInst(bar, "vastart.fix.2", CI);
+ CI->replaceAllUsesWith(foo);
CI->getParent()->getInstList().erase(CI);
}
Result->getFunctionList().erase(F);
}
- if (Function *F = Result->getNamedFunction("llvm.va_end")) {
- assert(F->asize() == 1 && "Obsolete va_end takes 1 argument!");
- const Type *ArgTy = F->getFunctionType()->getParamType(0);
- ArgTy = cast<PointerType>(ArgTy)->getElementType();
- Function *NF = Result->getOrInsertFunction("llvm.va_end", Type::VoidTy,
- ArgTy, 0);
+ if(Function* F = Result->getNamedFunction("llvm.va_end")) {
+ if(F->arg_size() != 1)
+ ThrowException("Obsolete va_end takes 1 argument!");
+
+ //vaend foo
+ // ->
+ //bar = alloca 1 of typeof(foo)
+ //vaend bar
+ const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
+ const Type* ArgTy = F->getFunctionType()->getParamType(0);
+ const Type* ArgTyPtr = PointerType::get(ArgTy);
+ Function* NF = Result->getOrInsertFunction("llvm.va_end",
+ RetTy, ArgTyPtr, (Type *)0);
while (!F->use_empty()) {
- CallInst *CI = cast<CallInst>(F->use_back());
- Value *V = new LoadInst(CI->getOperand(1), "", CI);
- new CallInst(NF, V, "", CI);
+ CallInst* CI = cast<CallInst>(F->use_back());
+ AllocaInst* bar = new AllocaInst(ArgTy, 0, "vaend.fix.1", CI);
+ new StoreInst(CI->getOperand(1), bar, CI);
+ new CallInst(NF, bar, "", CI);
CI->getParent()->getInstList().erase(CI);
}
Result->getFunctionList().erase(F);
}
- if (Function *F = Result->getNamedFunction("llvm.va_copy")) {
- assert(F->asize() == 2 && "Obsolete va_copy takes 2 argument!");
- const Type *ArgTy = F->getFunctionType()->getParamType(0);
- ArgTy = cast<PointerType>(ArgTy)->getElementType();
- Function *NF = Result->getOrInsertFunction("llvm.va_copy", ArgTy,
- ArgTy, 0);
+ if(Function* F = Result->getNamedFunction("llvm.va_copy")) {
+ if(F->arg_size() != 1)
+ ThrowException("Obsolete va_copy takes 1 argument!");
+ //foo = vacopy(bar)
+ // ->
+ //a = alloca 1 of typeof(foo)
+ //b = alloca 1 of typeof(foo)
+ //store bar -> b
+ //vacopy(a, b)
+ //foo = load a
+
+ const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
+ const Type* ArgTy = F->getFunctionType()->getReturnType();
+ const Type* ArgTyPtr = PointerType::get(ArgTy);
+ Function* NF = Result->getOrInsertFunction("llvm.va_copy",
+ RetTy, ArgTyPtr, ArgTyPtr,
+ (Type *)0);
while (!F->use_empty()) {
- CallInst *CI = cast<CallInst>(F->use_back());
- Value *V = new CallInst(NF, CI->getOperand(2), "", CI);
- new StoreInst(V, CI->getOperand(1), CI);
+ CallInst* CI = cast<CallInst>(F->use_back());
+ AllocaInst* a = new AllocaInst(ArgTy, 0, "vacopy.fix.1", CI);
+ AllocaInst* b = new AllocaInst(ArgTy, 0, "vacopy.fix.2", CI);
+ new StoreInst(CI->getOperand(1), b, CI);
+ new CallInst(NF, a, b, "", CI);
+ Value* foo = new LoadInst(a, "vacopy.fix.3", CI);
+ CI->replaceAllUsesWith(foo);
CI->getParent()->getInstList().erase(CI);
}
Result->getFunctionList().erase(F);
}
}
- llvmAsmin = stdin; // F is about to go away, don't use it anymore...
- ParserResult = 0;
-
return Result;
+
+ }
+
+//===----------------------------------------------------------------------===//
+// RunVMAsmParser - Define an interface to this parser
+//===----------------------------------------------------------------------===//
+//
+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);
+ }
}
%}
std::vector<std::pair<llvm::PATypeHolder*,char*> > *ArgList;
std::vector<llvm::Value*> *ValueList;
std::list<llvm::PATypeHolder> *TypeList;
+ // Represent the RHS of PHI node
std::list<std::pair<llvm::Value*,
- llvm::BasicBlock*> > *PHIList; // Represent the RHS of PHI node
+ llvm::BasicBlock*> > *PHIList;
std::vector<std::pair<llvm::Constant*, llvm::BasicBlock*> > *JumpTable;
std::vector<llvm::Constant*> *ConstVector;
%type <JumpTable> JumpTable
%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
%token <StrVal> VAR_ID LABELSTR STRINGCONSTANT
%type <StrVal> Name OptName OptAssign
-
+%type <UIntVal> OptAlign OptCAlign
+%type <StrVal> OptSection SectionString
%token IMPLEMENTATION ZEROINITIALIZER TRUETOK FALSETOK BEGINTOK ENDTOK
-%token DECLARE GLOBAL CONSTANT VOLATILE
-%token TO DOTDOTDOT NULL_TOK CONST INTERNAL LINKONCE WEAK APPENDING
-%token OPAQUE NOT EXTERNAL TARGET ENDIAN POINTERSIZE LITTLE BIG
+%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 SIDEEFFECT
+%token CC_TOK CCC_TOK CSRETCC_TOK FASTCC_TOK COLDCC_TOK
+%type <UIntVal> OptCallingConv
-// Basic Block Terminating Operators
-%token <TermOpVal> RET BR SWITCH INVOKE UNWIND
+// Basic Block Terminating Operators
+%token <TermOpVal> RET BR SWITCH INVOKE UNWIND UNREACHABLE
-// Binary Operators
-%type <BinaryOpVal> BinaryOps // all the binary operators
+// Binary Operators
%type <BinaryOpVal> ArithmeticOps LogicalOps SetCondOps // Binops Subcatagories
%token <BinaryOpVal> ADD SUB MUL DIV REM AND OR XOR
%token <BinaryOpVal> SETLE SETGE SETLT SETGT SETEQ SETNE // Binary Comarators
// Other Operators
%type <OtherOpVal> ShiftOps
-%token <OtherOpVal> PHI_TOK CALL CAST SELECT SHL SHR VAARG VANEXT
-%token VA_ARG // FIXME: OBSOLETE
+%token <OtherOpVal> PHI_TOK CAST SELECT SHL SHR VAARG
+%token <OtherOpVal> EXTRACTELEMENT INSERTELEMENT SHUFFLEVECTOR
+%token VAARG_old VANEXT_old //OBSOLETE
+
%start Module
%%
$$ = (int64_t)$1;
};
-// Operations that are notably excluded from this list include:
+// Operations that are notably excluded from this list include:
// RET, BR, & SWITCH because they end basic blocks and are treated specially.
//
ArithmeticOps: ADD | SUB | MUL | DIV | REM;
LogicalOps : AND | OR | XOR;
SetCondOps : SETLE | SETGE | SETLT | SETGT | SETEQ | SETNE;
-BinaryOps : ArithmeticOps | LogicalOps | SetCondOps;
ShiftOps : SHL | SHR;
OptAssign : Name '=' {
$$ = $1;
}
- | /*empty*/ {
- $$ = 0;
+ | /*empty*/ {
+ $$ = 0;
};
OptLinkage : INTERNAL { $$ = GlobalValue::InternalLinkage; } |
APPENDING { $$ = GlobalValue::AppendingLinkage; } |
/*empty*/ { $$ = GlobalValue::ExternalLinkage; };
+OptCallingConv : /*empty*/ { $$ = CallingConv::C; } |
+ CCC_TOK { $$ = CallingConv::C; } |
+ CSRETCC_TOK { $$ = CallingConv::CSRet; } |
+ FASTCC_TOK { $$ = CallingConv::Fast; } |
+ COLDCC_TOK { $$ = CallingConv::Cold; } |
+ CC_TOK EUINT64VAL {
+ if ((unsigned)$2 != $2)
+ ThrowException("Calling conv too large!");
+ $$ = $2;
+ };
+
+// OptAlign/OptCAlign - An optional alignment, and an optional alignment with
+// a comma before it.
+OptAlign : /*empty*/ { $$ = 0; } |
+ ALIGN EUINT64VAL {
+ $$ = $2;
+ if ($$ != 0 && !isPowerOf2_32($$))
+ ThrowException("Alignment must be a power of two!");
+};
+OptCAlign : /*empty*/ { $$ = 0; } |
+ ',' ALIGN EUINT64VAL {
+ $$ = $3;
+ if ($$ != 0 && !isPowerOf2_32($$))
+ ThrowException("Alignment must be a power of two!");
+};
+
+
+SectionString : SECTION STRINGCONSTANT {
+ for (unsigned i = 0, e = strlen($2); i != e; ++i)
+ if ($2[i] == '"' || $2[i] == '\\')
+ ThrowException("Invalid character in section name!");
+ $$ = $2;
+};
+
+OptSection : /*empty*/ { $$ = 0; } |
+ SectionString { $$ = $1; };
+
+// GlobalVarAttributes - Used to pass the attributes string on a global. CurGV
+// is set to be the global we are processing.
+//
+GlobalVarAttributes : /* empty */ {} |
+ ',' GlobalVarAttribute GlobalVarAttributes {};
+GlobalVarAttribute : SectionString {
+ CurGV->setSection($1);
+ free($1);
+ }
+ | ALIGN EUINT64VAL {
+ if ($2 != 0 && !isPowerOf2_32($2))
+ ThrowException("Alignment must be a power of two!");
+ CurGV->setAlignment($2);
+ };
+
//===----------------------------------------------------------------------===//
// Types includes all predefined types... except void, because it can only be
// used in specific contexts (function returning void for example). To have
}
| UpRTypesV '(' ArgTypeListI ')' { // Function derived type?
std::vector<const Type*> Params;
- mapto($3->begin(), $3->end(), std::back_inserter(Params),
- std::mem_fun_ref(&PATypeHolder::get));
+ for (std::list<llvm::PATypeHolder>::iterator I = $3->begin(),
+ E = $3->end(); I != E; ++I)
+ Params.push_back(*I);
bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
if (isVarArg) Params.pop_back();
$$ = new PATypeHolder(HandleUpRefs(ArrayType::get(*$4, (unsigned)$2)));
delete $4;
}
+ | '<' EUINT64VAL 'x' UpRTypes '>' { // Packed array type?
+ const llvm::Type* ElemTy = $4->get();
+ if ((unsigned)$2 != $2)
+ ThrowException("Unsigned result not equal to signed result");
+ if (!ElemTy->isPrimitiveType())
+ ThrowException("Elemental type of a PackedType must be primitive");
+ if (!isPowerOf2_32($2))
+ ThrowException("Vector length should be a power of 2!");
+ $$ = new PATypeHolder(HandleUpRefs(PackedType::get(*$4, (unsigned)$2)));
+ delete $4;
+ }
| '{' TypeListI '}' { // Structure type?
std::vector<const Type*> Elements;
- mapto($2->begin(), $2->end(), std::back_inserter(Elements),
- std::mem_fun_ref(&PATypeHolder::get));
+ for (std::list<llvm::PATypeHolder>::iterator I = $2->begin(),
+ E = $2->end(); I != E; ++I)
+ Elements.push_back(*I);
$$ = new PATypeHolder(HandleUpRefs(StructType::get(Elements)));
delete $2;
" when array has size " + itostr(NumElements) + "!");
std::vector<Constant*> Vals;
if (ETy == Type::SByteTy) {
- for (char *C = $3; C != EndStr; ++C)
+ for (signed char *C = (signed char *)$3; C != (signed char *)EndStr; ++C)
Vals.push_back(ConstantSInt::get(ETy, *C));
} else if (ETy == Type::UByteTy) {
- for (char *C = $3; C != EndStr; ++C)
- Vals.push_back(ConstantUInt::get(ETy, (unsigned char)*C));
+ for (unsigned char *C = (unsigned char *)$3;
+ C != (unsigned char*)EndStr; ++C)
+ Vals.push_back(ConstantUInt::get(ETy, *C));
} else {
free($3);
ThrowException("Cannot build string arrays of non byte sized elements!");
$$ = ConstantArray::get(ATy, Vals);
delete $1;
}
+ | Types '<' ConstVector '>' { // Nonempty unsized arr
+ const PackedType *PTy = dyn_cast<PackedType>($1->get());
+ if (PTy == 0)
+ ThrowException("Cannot make packed constant with type: '" +
+ (*$1)->getDescription() + "'!");
+ const Type *ETy = PTy->getElementType();
+ int NumElements = PTy->getNumElements();
+
+ // Verify that we have the correct size...
+ if (NumElements != -1 && NumElements != (int)$3->size())
+ ThrowException("Type mismatch: constant sized packed initialized with " +
+ utostr($3->size()) + " arguments, but has size of " +
+ itostr(NumElements) + "!");
+
+ // Verify all elements are correct type!
+ for (unsigned i = 0; i < $3->size(); i++) {
+ if (ETy != (*$3)[i]->getType())
+ ThrowException("Element #" + utostr(i) + " is not of type '" +
+ ETy->getDescription() +"' as required!\nIt is of type '"+
+ (*$3)[i]->getType()->getDescription() + "'.");
+ }
+
+ $$ = ConstantPacked::get(PTy, *$3);
+ delete $1; delete $3;
+ }
| Types '{' ConstVector '}' {
const StructType *STy = dyn_cast<StructType>($1->get());
if (STy == 0)
$$ = ConstantPointerNull::get(PTy);
delete $1;
}
+ | Types UNDEF {
+ $$ = UndefValue::get($1->get());
+ delete $1;
+ }
| Types SymbolicValueRef {
const PointerType *Ty = dyn_cast<PointerType>($1->get());
if (Ty == 0)
delete $1;
}
| Types ZEROINITIALIZER {
- $$ = Constant::getNullValue($1->get());
+ const Type *Ty = $1->get();
+ if (isa<FunctionType>(Ty) || Ty == Type::LabelTy || isa<OpaqueType>(Ty))
+ ThrowException("Cannot create a null initialized value of this type!");
+ $$ = Constant::getNullValue(Ty);
delete $1;
};
$$ = ConstantBool::False;
}
| FPType FPVAL { // Float & Double constants
+ if (!ConstantFP::isValueValidForType($1, $2))
+ ThrowException("Floating point constant invalid for type!!");
$$ = ConstantFP::get($1, $2);
};
ThrowException("Select operand types must match!");
$$ = ConstantExpr::getSelect($3, $5, $7);
}
- | BinaryOps '(' ConstVal ',' ConstVal ')' {
+ | ArithmeticOps '(' ConstVal ',' ConstVal ')' {
if ($3->getType() != $5->getType())
ThrowException("Binary operator types must match!");
+ // HACK: llvm 1.3 and earlier used to emit invalid pointer constant exprs.
+ // To retain backward compatibility with these early compilers, we emit a
+ // cast to the appropriate integer type automatically if we are in the
+ // broken case. See PR424 for more information.
+ if (!isa<PointerType>($3->getType())) {
+ $$ = ConstantExpr::get($1, $3, $5);
+ } else {
+ const Type *IntPtrTy = 0;
+ switch (CurModule.CurrentModule->getPointerSize()) {
+ case Module::Pointer32: IntPtrTy = Type::IntTy; break;
+ case Module::Pointer64: IntPtrTy = Type::LongTy; break;
+ default: ThrowException("invalid pointer binary constant expr!");
+ }
+ $$ = ConstantExpr::get($1, ConstantExpr::getCast($3, IntPtrTy),
+ ConstantExpr::getCast($5, IntPtrTy));
+ $$ = ConstantExpr::getCast($$, $3->getType());
+ }
+ }
+ | LogicalOps '(' ConstVal ',' ConstVal ')' {
+ if ($3->getType() != $5->getType())
+ ThrowException("Logical operator types must match!");
+ if (!$3->getType()->isIntegral()) {
+ if (!isa<PackedType>($3->getType()) ||
+ !cast<PackedType>($3->getType())->getElementType()->isIntegral())
+ ThrowException("Logical operator requires integral operands!");
+ }
+ $$ = ConstantExpr::get($1, $3, $5);
+ }
+ | SetCondOps '(' ConstVal ',' ConstVal ')' {
+ if ($3->getType() != $5->getType())
+ ThrowException("setcc operand types must match!");
$$ = ConstantExpr::get($1, $3, $5);
}
| ShiftOps '(' ConstVal ',' ConstVal ')' {
if (!$3->getType()->isInteger())
ThrowException("Shift constant expression requires integer operand!");
$$ = ConstantExpr::get($1, $3, $5);
+ }
+ | EXTRACTELEMENT '(' ConstVal ',' ConstVal ')' {
+ if (!ExtractElementInst::isValidOperands($3, $5))
+ ThrowException("Invalid extractelement operands!");
+ $$ = ConstantExpr::getExtractElement($3, $5);
+ }
+ | INSERTELEMENT '(' ConstVal ',' ConstVal ',' ConstVal ')' {
+ if (!InsertElementInst::isValidOperands($3, $5, $7))
+ ThrowException("Invalid insertelement operands!");
+ $$ = ConstantExpr::getInsertElement($3, $5, $7);
+ }
+ | SHUFFLEVECTOR '(' ConstVal ',' ConstVal ',' ConstVal ')' {
+ if (!ShuffleVectorInst::isValidOperands($3, $5, $7))
+ ThrowException("Invalid shufflevector operands!");
+ $$ = ConstantExpr::getShuffleVector($3, $5, $7);
};
| FunctionList FunctionProto {
$$ = $1;
}
+ | FunctionList MODULE ASM_TOK AsmBlock {
+ $$ = $1;
+ }
| FunctionList IMPLEMENTATION {
$$ = $1;
}
| ConstPool {
$$ = CurModule.CurrentModule;
- // Resolve circular types before we parse the body of the module
- ResolveTypes(CurModule.LateResolveTypes);
+ // Emit an error if there are any unresolved types left.
+ if (!CurModule.LateResolveTypes.empty()) {
+ const ValID &DID = CurModule.LateResolveTypes.begin()->first;
+ if (DID.Type == ValID::NameVal)
+ ThrowException("Reference to an undefined type: '"+DID.getName() + "'");
+ else
+ ThrowException("Reference to an undefined type: #" + itostr(DID.Num));
+ }
};
// ConstPool - Constants with optional names assigned to them.
-ConstPool : ConstPool OptAssign TYPE TypesV { // Types can be defined in the const pool
+ConstPool : ConstPool OptAssign TYPE TypesV {
// Eagerly resolve types. This is not an optimization, this is a
// requirement that is due to the fact that we could have this:
//
if (!setTypeName(*$4, $2) && !$2) {
// If this is a named type that is not a redefinition, add it to the slot
// table.
- if (inFunctionScope())
- CurFun.Types.push_back(*$4);
- else
- CurModule.Types.push_back(*$4);
+ CurModule.Types.push_back(*$4);
}
delete $4;
}
| ConstPool FunctionProto { // Function prototypes can be in const pool
}
+ | ConstPool MODULE ASM_TOK AsmBlock { // Asm blocks can be in the const pool
+ }
| ConstPool OptAssign OptLinkage GlobalType ConstVal {
if ($5 == 0) ThrowException("Global value initializer is not a constant!");
- ParseGlobalVariable($2, $3, $4, $5->getType(), $5);
+ CurGV = ParseGlobalVariable($2, $3, $4, $5->getType(), $5);
+ } GlobalVarAttributes {
+ CurGV = 0;
}
| ConstPool OptAssign EXTERNAL GlobalType Types {
- ParseGlobalVariable($2, GlobalValue::ExternalLinkage, $4, *$5, 0);
+ CurGV = ParseGlobalVariable($2, GlobalValue::ExternalLinkage,
+ $4, *$5, 0);
delete $5;
+ } GlobalVarAttributes {
+ CurGV = 0;
}
| ConstPool TARGET TargetDefinition {
}
+ | ConstPool DEPLIBS '=' LibrariesDefinition {
+ }
| /* empty: end of list */ {
};
+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);
+ else
+ CurModule.CurrentModule->setModuleInlineAsm(AsmSoFar+"\n"+NewAsm);
+};
BigOrLittle : BIG { $$ = Module::BigEndian; };
BigOrLittle : LITTLE { $$ = Module::LittleEndian; };
CurModule.CurrentModule->setPointerSize(Module::Pointer64);
else
ThrowException("Invalid pointer size: '" + utostr($3) + "'!");
+ }
+ | TRIPLE '=' STRINGCONSTANT {
+ CurModule.CurrentModule->setTargetTriple($3);
+ free($3);
};
+LibrariesDefinition : '[' LibList ']';
+
+LibList : LibList ',' STRINGCONSTANT {
+ CurModule.CurrentModule->addLibrary($3);
+ free($3);
+ }
+ | STRINGCONSTANT {
+ CurModule.CurrentModule->addLibrary($1);
+ free($1);
+ }
+ | /* empty: end of list */ {
+ }
+ ;
//===----------------------------------------------------------------------===//
// Rules to match Function Headers
$$ = 0;
};
-FunctionHeaderH : TypesV Name '(' ArgList ')' {
- UnEscapeLexed($2);
- std::string FunctionName($2);
- free($2); // Free strdup'd memory!
+FunctionHeaderH : OptCallingConv TypesV Name '(' ArgList ')'
+ OptSection OptAlign {
+ UnEscapeLexed($3);
+ std::string FunctionName($3);
+ free($3); // Free strdup'd memory!
- if (!(*$1)->isFirstClassType() && *$1 != Type::VoidTy)
+ if (!(*$2)->isFirstClassType() && *$2 != Type::VoidTy)
ThrowException("LLVM functions cannot return aggregate types!");
std::vector<const Type*> ParamTypeList;
- if ($4) { // If there are arguments...
- for (std::vector<std::pair<PATypeHolder*,char*> >::iterator I = $4->begin();
- I != $4->end(); ++I)
+ if ($5) { // If there are arguments...
+ for (std::vector<std::pair<PATypeHolder*,char*> >::iterator I = $5->begin();
+ I != $5->end(); ++I)
ParamTypeList.push_back(I->first->get());
}
bool isVarArg = ParamTypeList.size() && ParamTypeList.back() == Type::VoidTy;
if (isVarArg) ParamTypeList.pop_back();
- const FunctionType *FT = FunctionType::get(*$1, ParamTypeList, isVarArg);
+ const FunctionType *FT = FunctionType::get(*$2, ParamTypeList, isVarArg);
const PointerType *PFT = PointerType::get(FT);
- delete $1;
+ delete $2;
ValID ID;
if (!FunctionName.empty()) {
// Make sure to strip off any argument names so we can't get conflicts.
if (Fn->isExternal())
- for (Function::aiterator AI = Fn->abegin(), AE = Fn->aend();
+ for (Function::arg_iterator AI = Fn->arg_begin(), AE = Fn->arg_end();
AI != AE; ++AI)
AI->setName("");
}
CurFun.FunctionStart(Fn);
+ Fn->setCallingConv($1);
+ Fn->setAlignment($8);
+ if ($7) {
+ Fn->setSection($7);
+ free($7);
+ }
// Add all of the arguments we parsed to the function...
- if ($4) { // Is null if empty...
+ if ($5) { // Is null if empty...
if (isVarArg) { // Nuke the last entry
- assert($4->back().first->get() == Type::VoidTy && $4->back().second == 0&&
+ assert($5->back().first->get() == Type::VoidTy && $5->back().second == 0&&
"Not a varargs marker!");
- delete $4->back().first;
- $4->pop_back(); // Delete the last entry
+ delete $5->back().first;
+ $5->pop_back(); // Delete the last entry
}
- Function::aiterator ArgIt = Fn->abegin();
- for (std::vector<std::pair<PATypeHolder*, char*> >::iterator I =$4->begin();
- I != $4->end(); ++I, ++ArgIt) {
+ Function::arg_iterator ArgIt = Fn->arg_begin();
+ for (std::vector<std::pair<PATypeHolder*,char*> >::iterator I = $5->begin();
+ I != $5->end(); ++I, ++ArgIt) {
delete I->first; // Delete the typeholder...
setValueName(ArgIt, I->second); // Insert arg into symtab...
InsertValue(ArgIt);
}
- delete $4; // We're now done with the argument list
+ delete $5; // We're now done with the argument list
}
};
// Make sure that we keep track of the linkage type even if there was a
// previous "declare".
$$->setLinkage($1);
-
- // Resolve circular types before we parse the body of the function.
- ResolveTypes(CurFun.LateResolveTypes);
};
END : ENDTOK | '}'; // Allow end of '}' to end a function
// Rules to match Basic Blocks
//===----------------------------------------------------------------------===//
+OptSideEffect : /* empty */ {
+ $$ = false;
+ }
+ | SIDEEFFECT {
+ $$ = true;
+ };
+
ConstValueRef : ESINT64VAL { // A reference to a direct constant
$$ = ValID::create($1);
}
| NULL_TOK {
$$ = ValID::createNull();
}
+ | UNDEF {
+ $$ = ValID::createUndef();
+ }
+ | ZEROINITIALIZER { // A vector zero constant.
+ $$ = ValID::createZeroInit();
+ }
+ | '<' ConstVector '>' { // Nonempty unsized packed vector
+ const Type *ETy = (*$2)[0]->getType();
+ int NumElements = $2->size();
+
+ PackedType* pt = PackedType::get(ETy, NumElements);
+ PATypeHolder* PTy = new PATypeHolder(
+ HandleUpRefs(
+ PackedType::get(
+ ETy,
+ NumElements)
+ )
+ );
+
+ // Verify all elements are correct type!
+ for (unsigned i = 0; i < $2->size(); i++) {
+ if (ETy != (*$2)[i]->getType())
+ ThrowException("Element #" + utostr(i) + " is not of type '" +
+ ETy->getDescription() +"' as required!\nIt is of type '" +
+ (*$2)[i]->getType()->getDescription() + "'.");
+ }
+
+ $$ = ValID::create(ConstantPacked::get(pt, *$2));
+ delete PTy; delete $2;
+ }
| 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
}
| /* empty */ {
$$ = CurBB = getBBVal(ValID::create((int)CurFun.NextBBNum++), true);
+
+ // Make sure to move the basic block to the correct location in the
+ // function, instead of leaving it inserted wherever it was first
+ // referenced.
+ Function::BasicBlockListType &BBL =
+ CurFun.CurrentFunction->getBasicBlockList();
+ BBL.splice(BBL.end(), BBL, $$);
}
| LABELSTR {
$$ = CurBB = getBBVal(ValID::create($1), true);
+
+ // Make sure to move the basic block to the correct location in the
+ // function, instead of leaving it inserted wherever it was first
+ // referenced.
+ Function::BasicBlockListType &BBL =
+ CurFun.CurrentFunction->getBasicBlockList();
+ BBL.splice(BBL.end(), BBL, $$);
};
BBTerminatorInst : RET ResolvedVal { // Return with a result...
$$ = new BranchInst(getBBVal($6), getBBVal($9), getVal(Type::BoolTy, $3));
}
| SWITCH IntType ValueRef ',' LABEL ValueRef '[' JumpTable ']' {
- SwitchInst *S = new SwitchInst(getVal($2, $3), getBBVal($6));
+ SwitchInst *S = new SwitchInst(getVal($2, $3), getBBVal($6), $8->size());
$$ = S;
std::vector<std::pair<Constant*,BasicBlock*> >::iterator I = $8->begin(),
E = $8->end();
- for (; I != E; ++I)
- S->addCase(I->first, I->second);
+ for (; I != E; ++I) {
+ if (ConstantInt *CI = dyn_cast<ConstantInt>(I->first))
+ S->addCase(CI, I->second);
+ else
+ ThrowException("Switch case is constant, but not a simple integer!");
+ }
delete $8;
}
| SWITCH IntType ValueRef ',' LABEL ValueRef '[' ']' {
- SwitchInst *S = new SwitchInst(getVal($2, $3), getBBVal($6));
+ SwitchInst *S = new SwitchInst(getVal($2, $3), getBBVal($6), 0);
$$ = S;
}
- | INVOKE TypesV ValueRef '(' ValueRefListE ')' TO LABEL ValueRef
- UNWIND LABEL ValueRef {
+ | INVOKE OptCallingConv TypesV ValueRef '(' ValueRefListE ')'
+ TO LABEL ValueRef UNWIND LABEL ValueRef {
const PointerType *PFTy;
const FunctionType *Ty;
- if (!(PFTy = dyn_cast<PointerType>($2->get())) ||
+ if (!(PFTy = dyn_cast<PointerType>($3->get())) ||
!(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
// Pull out the types of all of the arguments...
std::vector<const Type*> ParamTypes;
- if ($5) {
- for (std::vector<Value*>::iterator I = $5->begin(), E = $5->end();
+ if ($6) {
+ for (std::vector<Value*>::iterator I = $6->begin(), E = $6->end();
I != E; ++I)
ParamTypes.push_back((*I)->getType());
}
bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy;
if (isVarArg) ParamTypes.pop_back();
- Ty = FunctionType::get($2->get(), ParamTypes, isVarArg);
+ Ty = FunctionType::get($3->get(), ParamTypes, isVarArg);
PFTy = PointerType::get(Ty);
}
- Value *V = getVal(PFTy, $3); // Get the function we're calling...
+ Value *V = getVal(PFTy, $4); // Get the function we're calling...
- BasicBlock *Normal = getBBVal($9);
- BasicBlock *Except = getBBVal($12);
+ BasicBlock *Normal = getBBVal($10);
+ BasicBlock *Except = getBBVal($13);
// Create the call node...
- if (!$5) { // Has no arguments?
+ if (!$6) { // Has no arguments?
$$ = new InvokeInst(V, Normal, Except, std::vector<Value*>());
} else { // Has arguments?
// Loop through FunctionType's arguments and ensure they are specified
//
FunctionType::param_iterator I = Ty->param_begin();
FunctionType::param_iterator E = Ty->param_end();
- std::vector<Value*>::iterator ArgI = $5->begin(), ArgE = $5->end();
+ std::vector<Value*>::iterator ArgI = $6->begin(), ArgE = $6->end();
for (; ArgI != ArgE && I != E; ++ArgI, ++I)
if ((*ArgI)->getType() != *I)
if (I != E || (ArgI != ArgE && !Ty->isVarArg()))
ThrowException("Invalid number of parameters detected!");
- $$ = new InvokeInst(V, Normal, Except, *$5);
+ $$ = new InvokeInst(V, Normal, Except, *$6);
}
- delete $2;
- delete $5;
+ cast<InvokeInst>($$)->setCallingConv($2);
+
+ delete $3;
+ delete $6;
}
| UNWIND {
$$ = new UnwindInst();
+ }
+ | UNREACHABLE {
+ $$ = new UnreachableInst();
};
// ValueRefListE - Just like ValueRefList, except that it may also be empty!
ValueRefListE : ValueRefList | /*empty*/ { $$ = 0; };
+OptTailCall : TAIL CALL {
+ $$ = true;
+ }
+ | CALL {
+ $$ = false;
+ };
+
+
+
InstVal : ArithmeticOps Types ValueRef ',' ValueRef {
- if (!(*$2)->isInteger() && !(*$2)->isFloatingPoint())
- ThrowException("Arithmetic operator requires integer or FP operands!");
+ if (!(*$2)->isInteger() && !(*$2)->isFloatingPoint() &&
+ !isa<PackedType>((*$2).get()))
+ ThrowException(
+ "Arithmetic operator requires integer, FP, or packed operands!");
+ if (isa<PackedType>((*$2).get()) && $1 == Instruction::Rem)
+ ThrowException("Rem not supported on packed types!");
$$ = BinaryOperator::create($1, getVal(*$2, $3), getVal(*$2, $5));
if ($$ == 0)
ThrowException("binary operator returned null!");
delete $2;
}
| LogicalOps Types ValueRef ',' ValueRef {
- if (!(*$2)->isIntegral())
- ThrowException("Logical operator requires integral operands!");
+ if (!(*$2)->isIntegral()) {
+ if (!isa<PackedType>($2->get()) ||
+ !cast<PackedType>($2->get())->getElementType()->isIntegral())
+ ThrowException("Logical operator requires integral operands!");
+ }
$$ = BinaryOperator::create($1, getVal(*$2, $3), getVal(*$2, $5));
if ($$ == 0)
ThrowException("binary operator returned null!");
delete $2;
}
| SetCondOps Types ValueRef ',' ValueRef {
+ if(isa<PackedType>((*$2).get())) {
+ ThrowException(
+ "PackedTypes currently not supported in setcc instructions!");
+ }
$$ = new SetCondInst($1, getVal(*$2, $3), getVal(*$2, $5));
if ($$ == 0)
ThrowException("binary operator returned null!");
ThrowException("select value types should match!");
$$ = new SelectInst($2, $4, $6);
}
- | VA_ARG ResolvedVal ',' Types {
- // FIXME: This is emulation code for an obsolete syntax. This should be
- // removed at some point.
- if (!ObsoleteVarArgs) {
- std::cerr << "WARNING: this file uses obsolete features. "
- << "Assemble and disassemble to update it.\n";
- ObsoleteVarArgs = true;
- }
-
- // First, load the valist...
- Instruction *CurVAList = new LoadInst($2, "");
- CurBB->getInstList().push_back(CurVAList);
-
- // Emit the vaarg instruction.
- $$ = new VAArgInst(CurVAList, *$4);
-
- // Now we must advance the pointer and update it in memory.
- Instruction *TheVANext = new VANextInst(CurVAList, *$4);
- CurBB->getInstList().push_back(TheVANext);
-
- CurBB->getInstList().push_back(new StoreInst(TheVANext, $2));
- delete $4;
- }
| VAARG ResolvedVal ',' Types {
+ NewVarArgs = true;
$$ = new VAArgInst($2, *$4);
delete $4;
}
- | VANEXT ResolvedVal ',' Types {
- $$ = new VANextInst($2, *$4);
+ | VAARG_old ResolvedVal ',' Types {
+ ObsoleteVarArgs = true;
+ const Type* ArgTy = $2->getType();
+ Function* NF = CurModule.CurrentModule->
+ getOrInsertFunction("llvm.va_copy", ArgTy, ArgTy, (Type *)0);
+
+ //b = vaarg a, t ->
+ //foo = alloca 1 of t
+ //bar = vacopy a
+ //store bar -> foo
+ //b = vaarg foo, t
+ AllocaInst* foo = new AllocaInst(ArgTy, 0, "vaarg.fix");
+ CurBB->getInstList().push_back(foo);
+ CallInst* bar = new CallInst(NF, $2);
+ CurBB->getInstList().push_back(bar);
+ CurBB->getInstList().push_back(new StoreInst(bar, foo));
+ $$ = new VAArgInst(foo, *$4);
+ delete $4;
+ }
+ | VANEXT_old ResolvedVal ',' Types {
+ ObsoleteVarArgs = true;
+ const Type* ArgTy = $2->getType();
+ Function* NF = CurModule.CurrentModule->
+ getOrInsertFunction("llvm.va_copy", ArgTy, ArgTy, (Type *)0);
+
+ //b = vanext a, t ->
+ //foo = alloca 1 of t
+ //bar = vacopy a
+ //store bar -> foo
+ //tmp = vaarg foo, t
+ //b = load foo
+ AllocaInst* foo = new AllocaInst(ArgTy, 0, "vanext.fix");
+ CurBB->getInstList().push_back(foo);
+ CallInst* bar = new CallInst(NF, $2);
+ CurBB->getInstList().push_back(bar);
+ CurBB->getInstList().push_back(new StoreInst(bar, foo));
+ Instruction* tmp = new VAArgInst(foo, *$4);
+ CurBB->getInstList().push_back(tmp);
+ $$ = new LoadInst(foo);
delete $4;
}
+ | EXTRACTELEMENT ResolvedVal ',' ResolvedVal {
+ if (!ExtractElementInst::isValidOperands($2, $4))
+ ThrowException("Invalid extractelement operands!");
+ $$ = new ExtractElementInst($2, $4);
+ }
+ | INSERTELEMENT ResolvedVal ',' ResolvedVal ',' ResolvedVal {
+ if (!InsertElementInst::isValidOperands($2, $4, $6))
+ ThrowException("Invalid insertelement operands!");
+ $$ = new InsertElementInst($2, $4, $6);
+ }
+ | SHUFFLEVECTOR ResolvedVal ',' ResolvedVal ',' ResolvedVal {
+ if (!ShuffleVectorInst::isValidOperands($2, $4, $6))
+ ThrowException("Invalid shufflevector operands!");
+ $$ = new ShuffleVectorInst($2, $4, $6);
+ }
| PHI_TOK PHIList {
const Type *Ty = $2->front().first->getType();
if (!Ty->isFirstClassType())
ThrowException("PHI node operands must be of first class type!");
$$ = new PHINode(Ty);
- $$->op_reserve($2->size()*2);
+ ((PHINode*)$$)->reserveOperandSpace($2->size());
while ($2->begin() != $2->end()) {
if ($2->front().first->getType() != Ty)
ThrowException("All elements of a PHI node must be of the same type!");
$2->pop_front();
}
delete $2; // Free the list...
- }
- | CALL TypesV ValueRef '(' ValueRefListE ')' {
+ }
+ | OptTailCall OptCallingConv TypesV ValueRef '(' ValueRefListE ')' {
const PointerType *PFTy;
const FunctionType *Ty;
- if (!(PFTy = dyn_cast<PointerType>($2->get())) ||
+ if (!(PFTy = dyn_cast<PointerType>($3->get())) ||
!(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
// Pull out the types of all of the arguments...
std::vector<const Type*> ParamTypes;
- if ($5) {
- for (std::vector<Value*>::iterator I = $5->begin(), E = $5->end();
+ if ($6) {
+ for (std::vector<Value*>::iterator I = $6->begin(), E = $6->end();
I != E; ++I)
ParamTypes.push_back((*I)->getType());
}
bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy;
if (isVarArg) ParamTypes.pop_back();
- Ty = FunctionType::get($2->get(), ParamTypes, isVarArg);
+ if (!(*$3)->isFirstClassType() && *$3 != Type::VoidTy)
+ ThrowException("LLVM functions cannot return aggregate types!");
+
+ Ty = FunctionType::get($3->get(), ParamTypes, isVarArg);
PFTy = PointerType::get(Ty);
}
- Value *V = getVal(PFTy, $3); // Get the function we're calling...
+ Value *V = getVal(PFTy, $4); // Get the function we're calling...
// Create the call node...
- if (!$5) { // Has no arguments?
+ if (!$6) { // Has no arguments?
// Make sure no arguments is a good thing!
if (Ty->getNumParams() != 0)
ThrowException("No arguments passed to a function that "
//
FunctionType::param_iterator I = Ty->param_begin();
FunctionType::param_iterator E = Ty->param_end();
- std::vector<Value*>::iterator ArgI = $5->begin(), ArgE = $5->end();
+ std::vector<Value*>::iterator ArgI = $6->begin(), ArgE = $6->end();
for (; ArgI != ArgE && I != E; ++ArgI, ++I)
if ((*ArgI)->getType() != *I)
if (I != E || (ArgI != ArgE && !Ty->isVarArg()))
ThrowException("Invalid number of parameters detected!");
- $$ = new CallInst(V, *$5);
+ $$ = new CallInst(V, *$6);
}
- delete $2;
- delete $5;
+ cast<CallInst>($$)->setTailCall($1);
+ cast<CallInst>($$)->setCallingConv($2);
+ delete $3;
+ delete $6;
}
| MemoryInst {
$$ = $1;
};
-MemoryInst : MALLOC Types {
- $$ = new MallocInst(*$2);
+
+MemoryInst : MALLOC Types OptCAlign {
+ $$ = new MallocInst(*$2, 0, $3);
delete $2;
}
- | MALLOC Types ',' UINT ValueRef {
- $$ = new MallocInst(*$2, getVal($4, $5));
+ | MALLOC Types ',' UINT ValueRef OptCAlign {
+ $$ = new MallocInst(*$2, getVal($4, $5), $6);
delete $2;
}
- | ALLOCA Types {
- $$ = new AllocaInst(*$2);
+ | ALLOCA Types OptCAlign {
+ $$ = new AllocaInst(*$2, 0, $3);
delete $2;
}
- | ALLOCA Types ',' UINT ValueRef {
- $$ = new AllocaInst(*$2, getVal($4, $5));
+ | ALLOCA Types ',' UINT ValueRef OptCAlign {
+ $$ = new AllocaInst(*$2, getVal($4, $5), $6);
delete $2;
}
| FREE ResolvedVal {
if (!isa<PointerType>($3->get()))
ThrowException("Can't load from nonpointer type: " +
(*$3)->getDescription());
+ if (!cast<PointerType>($3->get())->getElementType()->isFirstClassType())
+ ThrowException("Can't load from pointer of non-first-class type: " +
+ (*$3)->getDescription());
$$ = new LoadInst(getVal(*$3, $4), "", $1);
delete $3;
}
projects / oota-llvm.git / blobdiff