//===-- 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 "llvm/iMemory.h"
#include "llvm/iOperators.h"
#include "llvm/iPHINode.h"
+#include "llvm/Support/GetElementPtrTypeIterator.h"
#include "Support/STLExtras.h"
-#include "Support/DepthFirstIterator.h"
+#include <algorithm>
+#include <iostream>
#include <list>
#include <utility>
-#include <algorithm>
int yyerror(const char *ErrorMsg); // Forward declarations to prevent "implicit
int yylex(); // declaration" of xxx warnings.
int yyparse();
+namespace llvm {
+ std::string CurFilename;
+}
+using namespace llvm;
+
static Module *ParserResult;
-std::string CurFilename;
// DEBUG_UPREFS - Define this symbol if you want to enable debugging output
// relating to upreferences in the input stream.
#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;
+
+
// 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::vector<ValueList> &LateResolvers,
- std::vector<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::vector<ValueList> Values; // Module level numbered definitions
- std::vector<ValueList> LateResolveValues;
- std::vector<PATypeHolder> Types;
+ std::map<const Type *, ValueList> Values; // Module level numbered definitions
+ std::map<const Type *,ValueList> LateResolveValues;
+ std::vector<PATypeHolder> Types;
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
+ /// that we can resolve them later and print error messages as appropriate.
+ std::map<Value*, std::pair<ValID, int> > PlaceHolderInfo;
+
// GlobalRefs - This maintains a mapping between <Type, ValID>'s and forward
// references to global values. Global values may be referenced before they
// are defined, and if so, the temporary object that they represent is held
- // here. This is used for forward references of ConstantPointerRefs.
+ // here. This is used for forward references of GlobalValues.
//
typedef std::map<std::pair<const PointerType *,
- ValID>, GlobalVariable*> GlobalRefsType;
+ ValID>, GlobalValue*> GlobalRefsType;
GlobalRefsType GlobalRefs;
void ModuleDone() {
}
- // DeclareNewGlobalValue - Called every time a new GV has been defined. This
- // is used to remove things from the forward declaration map, resolving them
- // to the correct thing as needed.
- //
- void DeclareNewGlobalValue(GlobalValue *GV, ValID D) {
+ // 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.
+ GlobalValue *GetForwardRefForGlobal(const PointerType *PTy, ValID ID) {
// Check to see if there is a forward reference to this global variable...
// if there is, eliminate it and patch the reference to use the new def'n.
- GlobalRefsType::iterator I =
- GlobalRefs.find(std::make_pair(GV->getType(), D));
-
+ GlobalRefsType::iterator I = GlobalRefs.find(std::make_pair(PTy, ID));
+ GlobalValue *Ret = 0;
if (I != GlobalRefs.end()) {
- GlobalVariable *OldGV = I->second; // Get the placeholder...
- I->first.second.destroy(); // Free string memory if necessary
-
- // Loop over all of the uses of the GlobalValue. The only thing they are
- // allowed to be is ConstantPointerRef's.
- assert(OldGV->hasOneUse() && "Only one reference should exist!");
- User *U = OldGV->use_back(); // Must be a ConstantPointerRef...
- ConstantPointerRef *CPR = cast<ConstantPointerRef>(U);
-
- // Change the const pool reference to point to the real global variable
- // now. This should drop a use from the OldGV.
- CPR->mutateReferences(OldGV, GV);
- assert(OldGV->use_empty() && "All uses should be gone now!");
-
- // Remove OldGV from the module...
- CurrentModule->getGlobalList().remove(OldGV);
- delete OldGV; // Delete the old placeholder
-
- // Remove the map entry for the global now that it has been created...
+ Ret = I->second;
GlobalRefs.erase(I);
}
+ return Ret;
}
-
} CurModule;
static struct PerFunctionInfo {
Function *CurrentFunction; // Pointer to current function being created
- std::vector<ValueList> Values; // Keep track of numbered definitions
- std::vector<ValueList> LateResolveValues;
+ 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
+ /// track of them here.
+ std::map<BasicBlock*, std::pair<ValID, int> > BBForwardRefs;
+ std::vector<BasicBlock*> NumberedBlocks;
+ unsigned NextBBNum;
+
inline PerFunctionInfo() {
CurrentFunction = 0;
isDeclare = false;
inline void FunctionStart(Function *M) {
CurrentFunction = M;
+ NextBBNum = 0;
}
void FunctionDone() {
- // If we could not resolve some blocks at parsing time (forward branches)
- // resolve the branches now...
- ResolveDefinitions(LateResolveValues, &CurModule.LateResolveValues);
+ NumberedBlocks.clear();
- // Make sure to resolve any constant expr references that might exist within
- // the function we just declared itself.
- ValID FID;
- if (CurrentFunction->hasName()) {
- FID = ValID::create((char*)CurrentFunction->getName().c_str());
- } else {
- unsigned Slot = CurrentFunction->getType()->getUniqueID();
- assert(CurModule.Values.size() > Slot && "Function not inserted?");
- // Figure out which slot number if is...
- for (unsigned i = 0; ; ++i) {
- assert(i < CurModule.Values[Slot].size() && "Function not found!");
- if (CurModule.Values[Slot][i] == CurrentFunction) {
- FID = ValID::create((int)i);
- break;
- }
- }
- }
- CurModule.DeclareNewGlobalValue(CurrentFunction, FID);
+ // Any forward referenced blocks left?
+ if (!BBForwardRefs.empty())
+ ThrowException("Undefined reference to label " +
+ BBForwardRefs.begin()->second.first.getName());
+
+ // Resolve all forward references now.
+ ResolveDefinitions(LateResolveValues, &CurModule.LateResolveValues);
Values.clear(); // Clear out function local definitions
- Types.clear();
+ Types.clear(); // Clear out function local types
CurrentFunction = 0;
isDeclare = false;
}
// Code to handle definitions of all the types
//===----------------------------------------------------------------------===//
-static int InsertValue(Value *D,
- std::vector<ValueList> &ValueTab = CurFun.Values) {
- if (D->hasName()) return -1; // Is this a numbered definition?
+static int InsertValue(Value *V,
+ std::map<const Type*,ValueList> &ValueTab = CurFun.Values) {
+ if (V->hasName()) return -1; // Is this a numbered definition?
// Yes, insert the value into the value table...
- unsigned type = D->getType()->getUniqueID();
- if (ValueTab.size() <= type)
- ValueTab.resize(type+1, ValueList());
- //printf("Values[%d][%d] = %d\n", type, ValueTab[type].size(), D);
- ValueTab[type].push_back(D);
- return ValueTab[type].size()-1;
-}
-
-// TODO: FIXME when Type are not const
-static void InsertType(const Type *Ty, std::vector<PATypeHolder> &Types) {
- Types.push_back(Ty);
+ ValueList &List = ValueTab[V->getType()];
+ List.push_back(V);
+ return List.size()-1;
}
static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) {
switch (D.Type) {
- case ValID::NumberVal: { // Is it a numbered definition?
- unsigned Num = (unsigned)D.Num;
-
+ case ValID::NumberVal: // Is it a numbered definition?
// Module constants occupy the lowest numbered slots...
- if (Num < CurModule.Types.size())
- return CurModule.Types[Num];
-
- Num -= CurModule.Types.size();
-
- // Check that the number is within bounds...
- if (Num <= CurFun.Types.size())
- return CurFun.Types[Num];
+ if ((unsigned)D.Num < CurModule.Types.size())
+ return CurModule.Types[(unsigned)D.Num];
break;
- }
- case ValID::NameVal: { // Is it a named definition?
- std::string Name(D.Name);
- SymbolTable *SymTab = 0;
- Value *N = 0;
- if (inFunctionScope()) {
- SymTab = &CurFun.CurrentFunction->getSymbolTable();
- N = SymTab->lookup(Type::TypeTy, Name);
- }
-
- if (N == 0) {
- // Symbol table doesn't automatically chain yet... because the function
- // hasn't been added to the module...
- //
- SymTab = &CurModule.CurrentModule->getSymbolTable();
- N = SymTab->lookup(Type::TypeTy, Name);
- if (N == 0) break;
+ case ValID::NameVal: // Is it a named definition?
+ if (const Type *N = CurModule.CurrentModule->getTypeByName(D.Name)) {
+ D.destroy(); // Free old strdup'd memory...
+ return N;
}
-
- D.destroy(); // Free old strdup'd memory...
- return cast<Type>(N);
- }
+ break;
default:
ThrowException("Internal parser error: Invalid symbol type reference!");
}
switch (D.Type) {
case ValID::NumberVal: { // Is it a numbered definition?
- unsigned type = Ty->getUniqueID();
unsigned Num = (unsigned)D.Num;
// Module constants occupy the lowest numbered slots...
- if (type < CurModule.Values.size()) {
- if (Num < CurModule.Values[type].size())
- return CurModule.Values[type][Num];
-
- Num -= CurModule.Values[type].size();
+ std::map<const Type*,ValueList>::iterator VI = CurModule.Values.find(Ty);
+ if (VI != CurModule.Values.end()) {
+ if (Num < VI->second.size())
+ return VI->second[Num];
+ Num -= VI->second.size();
}
// Make sure that our type is within bounds
- if (CurFun.Values.size() <= type) return 0;
+ VI = CurFun.Values.find(Ty);
+ if (VI == CurFun.Values.end()) return 0;
// Check that the number is within bounds...
- if (CurFun.Values[type].size() <= Num) return 0;
+ if (VI->second.size() <= Num) return 0;
- return CurFun.Values[type][Num];
+ return VI->second[Num];
}
case ValID::NameVal: { // Is it a named definition?
case ValID::ConstUIntVal: // Is it an unsigned const pool reference?
if (!ConstantUInt::isValueValidForType(Ty, D.UConstPool64)) {
if (!ConstantSInt::isValueValidForType(Ty, D.ConstPool64)) {
- ThrowException("Integral constant '" + utostr(D.UConstPool64) +
+ ThrowException("Integral constant '" + utostr(D.UConstPool64) +
"' is invalid or out of range!");
} else { // This is really a signed reference. Transmogrify.
- return ConstantSInt::get(Ty, D.ConstPool64);
+ return ConstantSInt::get(Ty, D.ConstPool64);
}
} else {
return ConstantUInt::get(Ty, D.UConstPool64);
return 0;
}
-
// getVal - This function is identical to getValNonImprovising, except that if a
// value is not already defined, it "improvises" by creating a placeholder var
// that looks and acts just like the requested variable. When the value is
// defined later, all uses of the placeholder variable are replaced with the
// real thing.
//
-static Value *getVal(const Type *Ty, const ValID &D) {
- assert(Ty != Type::TypeTy && "Should use getTypeVal for types!");
+static Value *getVal(const Type *Ty, const ValID &ID) {
+ if (Ty == Type::LabelTy)
+ ThrowException("Cannot use a basic block here");
- // See if the value has already been defined...
- Value *V = getValNonImprovising(Ty, D);
+ // See if the value has already been defined.
+ Value *V = getValNonImprovising(Ty, ID);
if (V) return V;
// 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...
//
- Value *d = 0;
- switch (Ty->getPrimitiveID()) {
- case Type::LabelTyID: d = new BBPlaceHolder(Ty, D); break;
- default: d = new ValuePlaceHolder(Ty, D); break;
- }
+ V = new Argument(Ty);
+
+ // 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)));
- assert(d != 0 && "How did we not make something?");
if (inFunctionScope())
- InsertValue(d, CurFun.LateResolveValues);
+ InsertValue(V, CurFun.LateResolveValues);
else
- InsertValue(d, CurModule.LateResolveValues);
- return d;
+ InsertValue(V, CurModule.LateResolveValues);
+ return V;
+}
+
+/// getBBVal - This is used for two purposes:
+/// * If isDefinition is true, a new basic block with the specified ID is being
+/// defined.
+/// * If isDefinition is true, this is a reference to a basic block, which may
+/// or may not be a forward reference.
+///
+static BasicBlock *getBBVal(const ValID &ID, bool isDefinition = false) {
+ assert(inFunctionScope() && "Can't get basic block at global scope!");
+
+ std::string Name;
+ BasicBlock *BB = 0;
+ switch (ID.Type) {
+ default: ThrowException("Illegal label reference " + ID.getName());
+ case ValID::NumberVal: // Is it a numbered definition?
+ if (unsigned(ID.Num) >= CurFun.NumberedBlocks.size())
+ CurFun.NumberedBlocks.resize(ID.Num+1);
+ BB = CurFun.NumberedBlocks[ID.Num];
+ break;
+ case ValID::NameVal: // Is it a named definition?
+ Name = ID.Name;
+ if (Value *N = CurFun.CurrentFunction->
+ getSymbolTable().lookup(Type::LabelTy, Name))
+ BB = cast<BasicBlock>(N);
+ break;
+ }
+
+ // See if the block has already been defined.
+ if (BB) {
+ // If this is the definition of the block, make sure the existing value was
+ // just a forward reference. If it was a forward reference, there will be
+ // an entry for it in the PlaceHolderInfo map.
+ if (isDefinition && !CurFun.BBForwardRefs.erase(BB))
+ // The existing value was a definition, not a forward reference.
+ ThrowException("Redefinition of label " + ID.getName());
+
+ ID.destroy(); // Free strdup'd memory.
+ return BB;
+ }
+
+ // Otherwise this block has not been seen before.
+ BB = new BasicBlock("", CurFun.CurrentFunction);
+ if (ID.Type == ValID::NameVal) {
+ BB->setName(ID.Name);
+ } else {
+ CurFun.NumberedBlocks[ID.Num] = BB;
+ }
+
+ // If this is not a definition, keep track of it so we can use it as a forward
+ // reference.
+ if (!isDefinition) {
+ // Remember where this forward reference came from.
+ CurFun.BBForwardRefs[BB] = std::make_pair(ID, llvmAsmlineno);
+ } else {
+ // The forward declaration could have been inserted anywhere in the
+ // function: insert it into the correct place now.
+ CurFun.CurrentFunction->getBasicBlockList().remove(BB);
+ CurFun.CurrentFunction->getBasicBlockList().push_back(BB);
+ }
+
+ return BB;
}
// time (forward branches, phi functions for loops, etc...) resolve the
// defs now...
//
-static void ResolveDefinitions(std::vector<ValueList> &LateResolvers,
- std::vector<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 (unsigned ty = 0; ty < LateResolvers.size(); ty++) {
- while (!LateResolvers[ty].empty()) {
- Value *V = LateResolvers[ty].back();
- assert(!isa<Type>(V) && "Types should be in LateResolveTypes!");
+ for (std::map<const Type*,ValueList>::iterator LRI = LateResolvers.begin(),
+ E = LateResolvers.end(); LRI != E; ++LRI) {
+ ValueList &List = LRI->second;
+ while (!List.empty()) {
+ Value *V = List.back();
+ List.pop_back();
+
+ std::map<Value*, std::pair<ValID, int> >::iterator PHI =
+ CurModule.PlaceHolderInfo.find(V);
+ assert(PHI != CurModule.PlaceHolderInfo.end() && "Placeholder error!");
- LateResolvers[ty].pop_back();
- ValID &DID = getValIDFromPlaceHolder(V);
+ ValID &DID = PHI->second.first;
- Value *TheRealValue = getValNonImprovising(Type::getUniqueIDType(ty),DID);
+ Value *TheRealValue = getValNonImprovising(LRI->first, DID);
if (TheRealValue) {
V->replaceAllUsesWith(TheRealValue);
delete V;
+ CurModule.PlaceHolderInfo.erase(PHI);
} else if (FutureLateResolvers) {
// Functions have their unresolved items forwarded to the module late
// resolver table
InsertValue(V, *FutureLateResolvers);
} else {
- if (DID.Type == ValID::NameVal)
- ThrowException("Reference to an invalid definition: '" +DID.getName()+
- "' of type '" + V->getType()->getDescription() + "'",
- getLineNumFromPlaceHolder(V));
- else
- ThrowException("Reference to an invalid definition: #" +
- itostr(DID.Num) + " of type '" +
- V->getType()->getDescription() + "'",
- getLineNumFromPlaceHolder(V));
+ if (DID.Type == ValID::NameVal)
+ ThrowException("Reference to an invalid definition: '" +DID.getName()+
+ "' of type '" + V->getType()->getDescription() + "'",
+ PHI->second.second);
+ else
+ ThrowException("Reference to an invalid definition: #" +
+ itostr(DID.Num) + " of type '" +
+ V->getType()->getDescription() + "'",
+ PHI->second.second);
}
}
}
}
}
-
// setValueName - Set the specified value to the name given. The name may be
// 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) {
+ if (NameStr) {
+ std::string Name(NameStr); // Copy string
+ free(NameStr); // Free old string
+
+ 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);
+ }
+}
+
+/// 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) {
+ if (isa<FunctionType>(Ty))
+ ThrowException("Cannot declare global vars of function type!");
+
+ const PointerType *PTy = PointerType::get(Ty);
+
+ std::string Name;
+ if (NameStr) {
+ Name = NameStr; // Copy string
+ free(NameStr); // Free old string
+ }
+
+ // See if this global value was forward referenced. If so, recycle the
+ // object.
+ ValID ID;
+ if (!Name.empty()) {
+ ID = ValID::create((char*)Name.c_str());
+ } else {
+ ID = ValID::create((int)CurModule.Values[PTy].size());
+ }
+
+ if (GlobalValue *FWGV = CurModule.GetForwardRefForGlobal(PTy, ID)) {
+ // 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);
+ CurModule.CurrentModule->getGlobalList().push_back(GV);
+ GV->setInitializer(Initializer);
+ GV->setLinkage(Linkage);
+ GV->setConstant(isConstantGlobal);
+ InsertValue(GV, CurModule.Values);
+ return;
+ }
+
+ // If this global has a name, check to see if there is already a definition
+ // of this global in the module. If so, merge as appropriate. Note that
+ // this is really just a hack around problems in the CFE. :(
+ 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 =
+ 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
+ // 2. If both initializers have the same value.
+ //
+ if (!EGV->hasInitializer() || !Initializer ||
+ EGV->getInitializer() == Initializer) {
+
+ // Make sure the existing global version gets the initializer! Make
+ // sure that it also gets marked const if the new version is.
+ if (Initializer && !EGV->hasInitializer())
+ EGV->setInitializer(Initializer);
+ if (isConstantGlobal)
+ EGV->setConstant(true);
+ EGV->setLinkage(Linkage);
+ return;
+ }
+
+ 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,
+ CurModule.CurrentModule);
+ InsertValue(GV, CurModule.Values);
+}
+
+// setTypeName - Set the specified type to the name given. The name may be
+// null potentially, in which case this is a noop. The string passed in is
// assumed to be a malloc'd string buffer, and is freed by this function.
//
-// This function returns true if the value has already been defined, but is
+// 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 typeplane, false is returned.
-//
-static bool setValueName(Value *V, char *NameStr) {
+// for the type plane, it is inserted and false is returned.
+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
- if (V->getType() == Type::VoidTy)
- ThrowException("Can't assign name '" + Name +
- "' to a null valued instruction!");
+ // We don't allow assigning names to void type
+ 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.
+ bool AlreadyExists = CurModule.CurrentModule->addTypeName(Name, T);
- SymbolTable &ST = inFunctionScope() ?
- CurFun.CurrentFunction->getSymbolTable() :
- CurModule.CurrentModule->getSymbolTable();
+ if (AlreadyExists) { // Inserting a name that is already defined???
+ const Type *Existing = CurModule.CurrentModule->getTypeByName(Name);
+ assert(Existing && "Conflict but no matching type?");
- Value *Existing = ST.lookup(V->getType(), Name);
- if (Existing) { // Inserting a name that is already defined???
// There is only one case where this is allowed: when we are refining an
// opaque type. In this case, Existing will be an opaque type.
- if (const Type *Ty = dyn_cast<Type>(Existing)) {
- if (const OpaqueType *OpTy = dyn_cast<OpaqueType>(Ty)) {
- // We ARE replacing an opaque type!
- ((OpaqueType*)OpTy)->refineAbstractTypeTo(cast<Type>(V));
- return true;
- }
+ if (const OpaqueType *OpTy = dyn_cast<OpaqueType>(Existing)) {
+ // We ARE replacing an opaque type!
+ const_cast<OpaqueType*>(OpTy)->refineAbstractTypeTo(T);
+ return true;
}
- // Otherwise, we are a simple redefinition of a value, check to see if it
- // is defined the same as the old one...
- if (const Type *Ty = dyn_cast<Type>(Existing)) {
- if (Ty == cast<Type>(V)) return true; // Yes, it's equal.
- // std::cerr << "Type: " << Ty->getDescription() << " != "
- // << cast<Type>(V)->getDescription() << "!\n";
- } else if (const Constant *C = dyn_cast<Constant>(Existing)) {
- if (C == V) return true; // Constants are equal to themselves
- } else if (GlobalVariable *EGV = dyn_cast<GlobalVariable>(Existing)) {
- // We are allowed to redefine a global variable in two circumstances:
- // 1. If at least one of the globals is uninitialized or
- // 2. If both initializers have the same value.
- //
- if (GlobalVariable *GV = dyn_cast<GlobalVariable>(V)) {
- if (!EGV->hasInitializer() || !GV->hasInitializer() ||
- EGV->getInitializer() == GV->getInitializer()) {
-
- // Make sure the existing global version gets the initializer! Make
- // sure that it also gets marked const if the new version is.
- if (GV->hasInitializer() && !EGV->hasInitializer())
- EGV->setInitializer(GV->getInitializer());
- if (GV->isConstant())
- EGV->setConstant(true);
- EGV->setLinkage(GV->getLinkage());
-
- delete GV; // Destroy the duplicate!
- return true; // They are equivalent!
- }
- }
- }
- ThrowException("Redefinition of value named '" + Name + "' in the '" +
- V->getType()->getDescription() + "' type plane!");
+ // Otherwise, this is an attempt to redefine a type. That's okay if
+ // the redefinition is identical to the original. This will be so if
+ // Existing and T point to the same Type object. In this one case we
+ // allow the equivalent redefinition.
+ if (Existing == T) return true; // Yes, it's equal.
+
+ // Any other kind of (non-equivalent) redefinition is an error.
+ ThrowException("Redefinition of type named '" + Name + "' in the '" +
+ T->getDescription() + "' type plane!");
}
- V->setName(Name, &ST);
return false;
}
-
//===----------------------------------------------------------------------===//
// Code for handling upreferences in type names...
//
-// TypeContains - Returns true if Ty contains E in it.
+// TypeContains - Returns true if Ty directly contains E in it.
//
static bool TypeContains(const Type *Ty, const Type *E) {
- return find(df_begin(Ty), df_end(Ty), E) != df_end(Ty);
+ return find(Ty->subtype_begin(), Ty->subtype_end(), E) != Ty->subtype_end();
}
+namespace {
+ struct UpRefRecord {
+ // 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;
+
+ // UpRefTy - This is the actual opaque type that the upreference is
+ // represented with.
+ OpaqueType *UpRefTy;
+
+ UpRefRecord(unsigned NL, OpaqueType *URTy)
+ : NestingLevel(NL), LastContainedTy(URTy), UpRefTy(URTy) {}
+ };
+}
-static std::vector<std::pair<unsigned, OpaqueType *> > UpRefs;
+// UpRefs - A list of the outstanding upreferences that need to be resolved.
+static std::vector<UpRefRecord> UpRefs;
+/// HandleUpRefs - Every time we finish a new layer of types, this function is
+/// called. It loops through the UpRefs vector, which is a list of the
+/// currently active types. For each type, if the up reference is contained in
+/// the newly completed type, we decrement the level count. When the level
+/// count reaches zero, the upreferenced type is the type that is passed in:
+/// thus we can complete the cycle.
+///
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");
- for (unsigned i = 0; i < UpRefs.size(); ) {
+
+ // If we find any resolvable upreferences (i.e., those whose NestingLevel goes
+ // to zero), we resolve them all together before we resolve them to Ty. At
+ // the end of the loop, if there is anything to resolve to Ty, it will be in
+ // this variable.
+ OpaqueType *TypeToResolve = 0;
+
+ for (unsigned i = 0; i != UpRefs.size(); ++i) {
UR_OUT(" UR#" << i << " - TypeContains(" << Ty->getDescription() << ", "
- << UpRefs[i].second->getDescription() << ") = "
- << (TypeContains(Ty, UpRefs[i].second) ? "true" : "false") << endl);
- if (TypeContains(Ty, UpRefs[i].second)) {
- unsigned Level = --UpRefs[i].first; // Decrement level of upreference
- UR_OUT(" Uplevel Ref Level = " << Level << endl);
+ << 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!
- UR_OUT(" * Resolving upreference for "
- << UpRefs[i].second->getDescription() << endl;
- std::string OldName = UpRefs[i].second->getDescription());
- UpRefs[i].second->refineAbstractTypeTo(Ty);
- UpRefs.erase(UpRefs.begin()+i); // Remove from upreference list...
- UR_OUT(" * Type '" << OldName << "' refined upreference to: "
- << (const void*)Ty << ", " << Ty->getDescription() << endl);
- continue;
+ if (!TypeToResolve) {
+ TypeToResolve = UpRefs[i].UpRefTy;
+ } else {
+ UR_OUT(" * Resolving upreference for "
+ << UpRefs[i].second->getDescription() << "\n";
+ std::string OldName = UpRefs[i].UpRefTy->getDescription());
+ UpRefs[i].UpRefTy->refineAbstractTypeTo(TypeToResolve);
+ UR_OUT(" * Type '" << OldName << "' refined upreference to: "
+ << (const void*)Ty << ", " << Ty->getDescription() << "\n");
+ }
+ UpRefs.erase(UpRefs.begin()+i); // Remove from upreference list...
+ --i; // Do not skip the next element...
}
}
+ }
- ++i; // Otherwise, no resolve, move on...
+ if (TypeToResolve) {
+ UR_OUT(" * Resolving upreference for "
+ << UpRefs[i].second->getDescription() << "\n";
+ std::string OldName = TypeToResolve->getDescription());
+ TypeToResolve->refineAbstractTypeTo(Ty);
}
- // FIXME: TODO: this should return the updated type
+
return Ty;
}
// RunVMAsmParser - Define an interface to this parser
//===----------------------------------------------------------------------===//
//
-Module *RunVMAsmParser(const std::string &Filename, FILE *F) {
+Module *llvm::RunVMAsmParser(const std::string &Filename, FILE *F) {
llvmAsmin = F;
CurFilename = Filename;
llvmAsmlineno = 1; // Reset the current line number...
+ ObsoleteVarArgs = false;
// Allocate a new module to read
CurModule.CurrentModule = new Module(Filename);
- yyparse(); // Parse the file.
+
+ yyparse(); // Parse the file, potentially throwing exception
+
Module *Result = ParserResult;
+
+ // 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;
+ }
+
+ 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!");
+
+ const Type *RetTy = F->getFunctionType()->getParamType(0);
+ RetTy = cast<PointerType>(RetTy)->getElementType();
+ Function *NF = Result->getOrInsertFunction("llvm.va_start", RetTy, 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);
+ 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);
+
+ while (!F->use_empty()) {
+ CallInst *CI = cast<CallInst>(F->use_back());
+ Value *V = new LoadInst(CI->getOperand(1), "", CI);
+ new CallInst(NF, V, "", 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);
+
+ 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);
+ CI->getParent()->getInstList().erase(CI);
+ }
+ Result->getFunctionList().erase(F);
+ }
+ }
+
llvmAsmin = stdin; // F is about to go away, don't use it anymore...
ParserResult = 0;
%}
%union {
- Module *ModuleVal;
- Function *FunctionVal;
- std::pair<PATypeHolder*, char*> *ArgVal;
- BasicBlock *BasicBlockVal;
- TerminatorInst *TermInstVal;
- Instruction *InstVal;
- Constant *ConstVal;
-
- const Type *PrimType;
- PATypeHolder *TypeVal;
- Value *ValueVal;
-
- std::vector<std::pair<PATypeHolder*,char*> > *ArgList;
- std::vector<Value*> *ValueList;
- std::list<PATypeHolder> *TypeList;
- std::list<std::pair<Value*,
- BasicBlock*> > *PHIList; // Represent the RHS of PHI node
- std::vector<std::pair<Constant*, BasicBlock*> > *JumpTable;
- std::vector<Constant*> *ConstVector;
-
- GlobalValue::LinkageTypes Linkage;
+ llvm::Module *ModuleVal;
+ llvm::Function *FunctionVal;
+ std::pair<llvm::PATypeHolder*, char*> *ArgVal;
+ llvm::BasicBlock *BasicBlockVal;
+ llvm::TerminatorInst *TermInstVal;
+ llvm::Instruction *InstVal;
+ llvm::Constant *ConstVal;
+
+ const llvm::Type *PrimType;
+ llvm::PATypeHolder *TypeVal;
+ llvm::Value *ValueVal;
+
+ std::vector<std::pair<llvm::PATypeHolder*,char*> > *ArgList;
+ std::vector<llvm::Value*> *ValueList;
+ std::list<llvm::PATypeHolder> *TypeList;
+ std::list<std::pair<llvm::Value*,
+ llvm::BasicBlock*> > *PHIList; // Represent the RHS of PHI node
+ std::vector<std::pair<llvm::Constant*, llvm::BasicBlock*> > *JumpTable;
+ std::vector<llvm::Constant*> *ConstVector;
+
+ llvm::GlobalValue::LinkageTypes Linkage;
int64_t SInt64Val;
uint64_t UInt64Val;
int SIntVal;
bool BoolVal;
char *StrVal; // This memory is strdup'd!
- ValID ValIDVal; // strdup'd memory maybe!
+ llvm::ValID ValIDVal; // strdup'd memory maybe!
- Instruction::BinaryOps BinaryOpVal;
- Instruction::TermOps TermOpVal;
- Instruction::MemoryOps MemOpVal;
- Instruction::OtherOps OtherOpVal;
- Module::Endianness Endianness;
+ llvm::Instruction::BinaryOps BinaryOpVal;
+ llvm::Instruction::TermOps TermOpVal;
+ llvm::Instruction::MemoryOps MemOpVal;
+ llvm::Instruction::OtherOps OtherOpVal;
+ llvm::Module::Endianness Endianness;
}
%type <ModuleVal> Module FunctionList
%type <StrVal> Name OptName OptAssign
-%token IMPLEMENTATION ZEROINITIALIZER TRUE FALSE BEGINTOK ENDTOK
+%token IMPLEMENTATION ZEROINITIALIZER TRUETOK FALSETOK BEGINTOK ENDTOK
%token DECLARE GLOBAL CONSTANT VOLATILE
-%token TO EXCEPT DOTDOTDOT NULL_TOK CONST INTERNAL LINKONCE WEAK APPENDING
+%token TO DOTDOTDOT NULL_TOK CONST INTERNAL LINKONCE WEAK APPENDING
%token OPAQUE NOT EXTERNAL TARGET ENDIAN POINTERSIZE LITTLE BIG
// Basic Block Terminating Operators
// Other Operators
%type <OtherOpVal> ShiftOps
-%token <OtherOpVal> PHI CALL CAST SHL SHR VA_ARG
+%token <OtherOpVal> PHI_TOK CALL CAST SELECT SHL SHR VAARG VANEXT
+%token VA_ARG // FIXME: OBSOLETE
%start Module
%%
UpRTypesV : UpRTypes | VOID { $$ = new PATypeHolder($1); };
Types : UpRTypes {
- if (UpRefs.size())
+ if (!UpRefs.empty())
ThrowException("Invalid upreference in type: " + (*$1)->getDescription());
$$ = $1;
};
// Include derived types in the Types production.
//
UpRTypes : '\\' EUINT64VAL { // Type UpReference
- if ($2 > (uint64_t)INT64_MAX) ThrowException("Value out of range!");
+ if ($2 > (uint64_t)~0U) ThrowException("Value out of range!");
OpaqueType *OT = OpaqueType::get(); // Use temporary placeholder
- UpRefs.push_back(std::make_pair((unsigned)$2, OT)); // Add to vector...
+ UpRefs.push_back(UpRefRecord((unsigned)$2, OT)); // Add to vector...
$$ = new PATypeHolder(OT);
UR_OUT("New Upreference!\n");
}
| 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));
+ std::mem_fun_ref(&PATypeHolder::get));
bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
if (isVarArg) Params.pop_back();
$$ = new PATypeHolder(HandleUpRefs(FunctionType::get(*$1,Params,isVarArg)));
delete $3; // Delete the argument list
- delete $1; // Delete the old type handle
+ delete $1; // Delete the return type handle
}
| '[' EUINT64VAL 'x' UpRTypes ']' { // Sized array type?
$$ = new PATypeHolder(HandleUpRefs(ArrayType::get(*$4, (unsigned)$2)));
| '{' TypeListI '}' { // Structure type?
std::vector<const Type*> Elements;
mapto($2->begin(), $2->end(), std::back_inserter(Elements),
- std::mem_fun_ref(&PATypeHolder::get));
+ std::mem_fun_ref(&PATypeHolder::get));
$$ = new PATypeHolder(HandleUpRefs(StructType::get(Elements)));
delete $2;
// Verify that we have the correct size...
if (NumElements != -1 && NumElements != (int)$3->size())
ThrowException("Type mismatch: constant sized array initialized with " +
- utostr($3->size()) + " arguments, but has size of " +
- itostr(NumElements) + "!");
+ 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() + "'.");
+ ThrowException("Element #" + utostr(i) + " is not of type '" +
+ ETy->getDescription() +"' as required!\nIt is of type '"+
+ (*$3)[i]->getType()->getDescription() + "'.");
}
$$ = ConstantArray::get(ATy, *$3);
int NumElements = ATy->getNumElements();
if (NumElements != -1 && NumElements != 0)
ThrowException("Type mismatch: constant sized array initialized with 0"
- " arguments, but has size of " + itostr(NumElements) +"!");
+ " arguments, but has size of " + itostr(NumElements) +"!");
$$ = ConstantArray::get(ATy, std::vector<Constant*>());
delete $1;
}
char *EndStr = UnEscapeLexed($3, true);
if (NumElements != -1 && NumElements != (EndStr-$3))
ThrowException("Can't build string constant of size " +
- itostr((int)(EndStr-$3)) +
- " when array has size " + itostr(NumElements) + "!");
+ itostr((int)(EndStr-$3)) +
+ " when array has size " + itostr(NumElements) + "!");
std::vector<Constant*> Vals;
if (ETy == Type::SByteTy) {
for (char *C = $3; C != EndStr; ++C)
- Vals.push_back(ConstantSInt::get(ETy, *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));
+ Vals.push_back(ConstantUInt::get(ETy, (unsigned char)*C));
} else {
free($3);
ThrowException("Cannot build string arrays of non byte sized elements!");
// Check to ensure that constants are compatible with the type initializer!
for (unsigned i = 0, e = $3->size(); i != e; ++i)
- if ((*$3)[i]->getType() != STy->getElementTypes()[i])
+ if ((*$3)[i]->getType() != STy->getElementType(i))
ThrowException("Expected type '" +
- STy->getElementTypes()[i]->getDescription() +
+ STy->getElementType(i)->getDescription() +
"' for element #" + utostr(i) +
" of structure initializer!");
ThrowException("Global const reference must be a pointer type!");
// ConstExprs can exist in the body of a function, thus creating
- // ConstantPointerRefs whenever they refer to a variable. Because we are in
+ // GlobalValues whenever they refer to a variable. Because we are in
// the context of a function, getValNonImprovising will search the functions
// symbol table instead of the module symbol table for the global symbol,
// which throws things all off. To get around this, we just tell
// First check to see if the forward references value is already created!
PerModuleInfo::GlobalRefsType::iterator I =
- CurModule.GlobalRefs.find(std::make_pair(PT, $2));
+ CurModule.GlobalRefs.find(std::make_pair(PT, $2));
if (I != CurModule.GlobalRefs.end()) {
- V = I->second; // Placeholder already exists, use it...
+ V = I->second; // Placeholder already exists, use it...
+ $2.destroy();
} else {
- // TODO: Include line number info by creating a subclass of
- // TODO: GlobalVariable here that includes the said information!
-
- // Create a placeholder for the global variable reference...
- GlobalVariable *GV = new GlobalVariable(PT->getElementType(),
- false,
- GlobalValue::ExternalLinkage);
- // Keep track of the fact that we have a forward ref to recycle it
- CurModule.GlobalRefs.insert(std::make_pair(std::make_pair(PT, $2), GV));
-
- // Must temporarily push this value into the module table...
- CurModule.CurrentModule->getGlobalList().push_back(GV);
- V = GV;
+ std::string Name;
+ if ($2.Type == ValID::NameVal) Name = $2.Name;
+
+ // Create the forward referenced global.
+ GlobalValue *GV;
+ if (const FunctionType *FTy =
+ dyn_cast<FunctionType>(PT->getElementType())) {
+ GV = new Function(FTy, GlobalValue::ExternalLinkage, Name,
+ CurModule.CurrentModule);
+ } else {
+ GV = new GlobalVariable(PT->getElementType(), false,
+ GlobalValue::ExternalLinkage, 0,
+ Name, CurModule.CurrentModule);
+ }
+
+ // Keep track of the fact that we have a forward ref to recycle it
+ CurModule.GlobalRefs.insert(std::make_pair(std::make_pair(PT, $2), GV));
+ V = GV;
}
}
- GlobalValue *GV = cast<GlobalValue>(V);
- $$ = ConstantPointerRef::get(GV);
+ $$ = cast<GlobalValue>(V);
delete $1; // Free the type handle
}
| Types ConstExpr {
ThrowException("Constant value doesn't fit in type!");
$$ = ConstantUInt::get($1, $2);
}
- | BOOL TRUE { // Boolean constants
+ | BOOL TRUETOK { // Boolean constants
$$ = ConstantBool::True;
}
- | BOOL FALSE { // Boolean constants
+ | BOOL FALSETOK { // Boolean constants
$$ = ConstantBool::False;
}
| FPType FPVAL { // Float & Double constants
ConstExpr: CAST '(' ConstVal TO Types ')' {
+ if (!$3->getType()->isFirstClassType())
+ ThrowException("cast constant expression from a non-primitive type: '" +
+ $3->getType()->getDescription() + "'!");
if (!$5->get()->isFirstClassType())
ThrowException("cast constant expression to a non-primitive type: '" +
$5->get()->getDescription() + "'!");
if (!isa<PointerType>($3->getType()))
ThrowException("GetElementPtr requires a pointer operand!");
+ // LLVM 1.2 and earlier used ubyte struct indices. Convert any ubyte struct
+ // indices to uint struct indices for compatibility.
+ generic_gep_type_iterator<std::vector<Value*>::iterator>
+ GTI = gep_type_begin($3->getType(), $4->begin(), $4->end()),
+ GTE = gep_type_end($3->getType(), $4->begin(), $4->end());
+ for (unsigned i = 0, e = $4->size(); i != e && GTI != GTE; ++i, ++GTI)
+ if (isa<StructType>(*GTI)) // Only change struct indices
+ if (ConstantUInt *CUI = dyn_cast<ConstantUInt>((*$4)[i]))
+ if (CUI->getType() == Type::UByteTy)
+ (*$4)[i] = ConstantExpr::getCast(CUI, Type::UIntTy);
+
const Type *IdxTy =
GetElementPtrInst::getIndexedType($3->getType(), *$4, true);
if (!IdxTy)
$$ = ConstantExpr::getGetElementPtr($3, IdxVec);
}
+ | SELECT '(' ConstVal ',' ConstVal ',' ConstVal ')' {
+ if ($3->getType() != Type::BoolTy)
+ ThrowException("Select condition must be of boolean type!");
+ if ($5->getType() != $7->getType())
+ ThrowException("Select operand types must match!");
+ $$ = ConstantExpr::getSelect($3, $5, $7);
+ }
| BinaryOps '(' ConstVal ',' ConstVal ')' {
if ($3->getType() != $5->getType())
ThrowException("Binary operator types must match!");
| ShiftOps '(' ConstVal ',' ConstVal ')' {
if ($5->getType() != Type::UByteTy)
ThrowException("Shift count for shift constant must be unsigned byte!");
- if (!$3->getType()->isIntegral())
- ThrowException("Shift constant expression requires integral operand!");
- $$ = ConstantExpr::getShift($1, $3, $5);
+ if (!$3->getType()->isInteger())
+ ThrowException("Shift constant expression requires integer operand!");
+ $$ = ConstantExpr::get($1, $3, $5);
};
//
FunctionList : FunctionList Function {
$$ = $1;
- assert($2->getParent() == 0 && "Function already in module!");
- $1->getFunctionList().push_back($2);
CurFun.FunctionDone();
}
| FunctionList FunctionProto {
};
// ConstPool - Constants with optional names assigned to them.
-ConstPool : ConstPool OptAssign CONST ConstVal {
- if (!setValueName($4, $2))
- InsertValue($4);
- }
- | ConstPool OptAssign TYPE TypesV { // Types can be defined in the const pool
+ConstPool : ConstPool OptAssign TYPE TypesV { // Types can be defined in the const pool
// Eagerly resolve types. This is not an optimization, this is a
// requirement that is due to the fact that we could have this:
//
// If types are not resolved eagerly, then the two types will not be
// determined to be the same type!
//
- ResolveTypeTo($2, $4->get());
-
- // TODO: FIXME when Type are not const
- if (!setValueName(const_cast<Type*>($4->get()), $2)) {
- // If this is not a redefinition of a type...
- if (!$2) {
- InsertType($4->get(),
- inFunctionScope() ? CurFun.Types : CurModule.Types);
- }
+ ResolveTypeTo($2, *$4);
+
+ 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);
}
delete $4;
| ConstPool FunctionProto { // Function prototypes can be in const pool
}
| ConstPool OptAssign OptLinkage GlobalType ConstVal {
- const Type *Ty = $5->getType();
- // Global declarations appear in Constant Pool
- Constant *Initializer = $5;
- if (Initializer == 0)
- ThrowException("Global value initializer is not a constant!");
-
- GlobalVariable *GV = new GlobalVariable(Ty, $4, $3, Initializer);
- if (!setValueName(GV, $2)) { // If not redefining...
- CurModule.CurrentModule->getGlobalList().push_back(GV);
- int Slot = InsertValue(GV, CurModule.Values);
-
- if (Slot != -1) {
- CurModule.DeclareNewGlobalValue(GV, ValID::create(Slot));
- } else {
- CurModule.DeclareNewGlobalValue(GV, ValID::create(
- (char*)GV->getName().c_str()));
- }
- }
+ if ($5 == 0) ThrowException("Global value initializer is not a constant!");
+ ParseGlobalVariable($2, $3, $4, $5->getType(), $5);
}
| ConstPool OptAssign EXTERNAL GlobalType Types {
- const Type *Ty = *$5;
- // Global declarations appear in Constant Pool
- GlobalVariable *GV = new GlobalVariable(Ty,$4,GlobalValue::ExternalLinkage);
- if (!setValueName(GV, $2)) { // If not redefining...
- CurModule.CurrentModule->getGlobalList().push_back(GV);
- int Slot = InsertValue(GV, CurModule.Values);
-
- if (Slot != -1) {
- CurModule.DeclareNewGlobalValue(GV, ValID::create(Slot));
- } else {
- assert(GV->hasName() && "Not named and not numbered!?");
- CurModule.DeclareNewGlobalValue(GV, ValID::create(
- (char*)GV->getName().c_str()));
- }
- }
+ ParseGlobalVariable($2, GlobalValue::ExternalLinkage, $4, *$5, 0);
delete $5;
}
| ConstPool TARGET TargetDefinition {
FunctionHeaderH : TypesV Name '(' ArgList ')' {
UnEscapeLexed($2);
std::string FunctionName($2);
+ free($2); // Free strdup'd memory!
+ if (!(*$1)->isFirstClassType() && *$1 != 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();
const PointerType *PFT = PointerType::get(FT);
delete $1;
+ ValID ID;
+ if (!FunctionName.empty()) {
+ ID = ValID::create((char*)FunctionName.c_str());
+ } else {
+ ID = ValID::create((int)CurModule.Values[PFT].size());
+ }
+
Function *Fn = 0;
- // Is the function already in symtab?
- if ((Fn = CurModule.CurrentModule->getFunction(FunctionName, FT))) {
- // Yes it is. If this is the case, either we need to be a forward decl,
- // or it needs to be.
+ // See if this function was forward referenced. If so, recycle the object.
+ if (GlobalValue *FWRef = CurModule.GetForwardRefForGlobal(PFT, ID)) {
+ // Move the function to the end of the list, from whereever it was
+ // previously inserted.
+ Fn = cast<Function>(FWRef);
+ 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, FT))) {
+ // If this is the case, either we need to be a forward decl, or it needs
+ // to be.
if (!CurFun.isDeclare && !Fn->isExternal())
ThrowException("Redefinition of function '" + FunctionName + "'!");
- // If we found a preexisting function prototype, remove it from the
- // module, so that we don't get spurious conflicts with global & local
- // variables.
- //
- CurModule.CurrentModule->getFunctionList().remove(Fn);
-
- // Make sure to strip off any argument names so we can't get conflicts...
- for (Function::aiterator AI = Fn->abegin(), AE = Fn->aend(); AI != AE; ++AI)
- AI->setName("");
+ // 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();
+ AI != AE; ++AI)
+ AI->setName("");
} else { // Not already defined?
- Fn = new Function(FT, GlobalValue::ExternalLinkage, FunctionName);
+ Fn = new Function(FT, GlobalValue::ExternalLinkage, FunctionName,
+ CurModule.CurrentModule);
InsertValue(Fn, CurModule.Values);
- CurModule.DeclareNewGlobalValue(Fn, ValID::create($2));
}
- free($2); // Free strdup'd memory!
CurFun.FunctionStart(Fn);
I != $4->end(); ++I, ++ArgIt) {
delete I->first; // Delete the typeholder...
- if (setValueName(ArgIt, I->second)) // Insert arg into symtab...
- assert(0 && "No arg redef allowed!");
-
+ setValueName(ArgIt, I->second); // Insert arg into symtab...
InsertValue(ArgIt);
}
FunctionProto : DECLARE { CurFun.isDeclare = true; } FunctionHeaderH {
$$ = CurFun.CurrentFunction;
- assert($$->getParent() == 0 && "Function already in module!");
- CurModule.CurrentModule->getFunctionList().push_back($$);
CurFun.FunctionDone();
};
| FPVAL { // Perhaps it's an FP constant?
$$ = ValID::create($1);
}
- | TRUE {
+ | TRUETOK {
$$ = ValID::create(ConstantBool::True);
}
- | FALSE {
+ | FALSETOK {
$$ = ValID::create(ConstantBool::False);
}
| NULL_TOK {
};
BasicBlockList : BasicBlockList BasicBlock {
- ($$ = $1)->getBasicBlockList().push_back($2);
+ $$ = $1;
}
| FunctionHeader BasicBlock { // Do not allow functions with 0 basic blocks
- ($$ = $1)->getBasicBlockList().push_back($2);
+ $$ = $1;
};
// br, br/cc, switch, ret
//
BasicBlock : InstructionList OptAssign BBTerminatorInst {
- if (setValueName($3, $2)) { assert(0 && "No redefn allowed!"); }
+ setValueName($3, $2);
InsertValue($3);
$1->getInstList().push_back($3);
InsertValue($1);
$$ = $1;
- }
- | LABELSTR InstructionList OptAssign BBTerminatorInst {
- if (setValueName($4, $3)) { assert(0 && "No redefn allowed!"); }
- InsertValue($4);
-
- $2->getInstList().push_back($4);
- if (setValueName($2, $1)) { assert(0 && "No label redef allowed!"); }
-
- InsertValue($2);
- $$ = $2;
};
InstructionList : InstructionList Inst {
$$ = $1;
}
| /* empty */ {
- $$ = new BasicBlock();
+ $$ = CurBB = getBBVal(ValID::create((int)CurFun.NextBBNum++), true);
+ }
+ | LABELSTR {
+ $$ = CurBB = getBBVal(ValID::create($1), true);
};
BBTerminatorInst : RET ResolvedVal { // Return with a result...
$$ = new ReturnInst();
}
| BR LABEL ValueRef { // Unconditional Branch...
- $$ = new BranchInst(cast<BasicBlock>(getVal(Type::LabelTy, $3)));
+ $$ = new BranchInst(getBBVal($3));
} // Conditional Branch...
| BR BOOL ValueRef ',' LABEL ValueRef ',' LABEL ValueRef {
- $$ = new BranchInst(cast<BasicBlock>(getVal(Type::LabelTy, $6)),
- cast<BasicBlock>(getVal(Type::LabelTy, $9)),
- getVal(Type::BoolTy, $3));
+ $$ = new BranchInst(getBBVal($6), getBBVal($9), getVal(Type::BoolTy, $3));
}
| SWITCH IntType ValueRef ',' LABEL ValueRef '[' JumpTable ']' {
- SwitchInst *S = new SwitchInst(getVal($2, $3),
- cast<BasicBlock>(getVal(Type::LabelTy, $6)));
+ SwitchInst *S = new SwitchInst(getVal($2, $3), getBBVal($6));
$$ = S;
std::vector<std::pair<Constant*,BasicBlock*> >::iterator I = $8->begin(),
E = $8->end();
for (; I != E; ++I)
S->addCase(I->first, I->second);
+ delete $8;
}
| SWITCH IntType ValueRef ',' LABEL ValueRef '[' ']' {
- SwitchInst *S = new SwitchInst(getVal($2, $3),
- cast<BasicBlock>(getVal(Type::LabelTy, $6)));
+ SwitchInst *S = new SwitchInst(getVal($2, $3), getBBVal($6));
$$ = S;
}
- | INVOKE TypesV ValueRef '(' ValueRefListE ')' TO ResolvedVal
- EXCEPT ResolvedVal {
+ | INVOKE TypesV ValueRef '(' ValueRefListE ')' TO LABEL ValueRef
+ UNWIND LABEL ValueRef {
const PointerType *PFTy;
const FunctionType *Ty;
Ty = FunctionType::get($2->get(), ParamTypes, isVarArg);
PFTy = PointerType::get(Ty);
}
- delete $2;
Value *V = getVal(PFTy, $3); // Get the function we're calling...
- BasicBlock *Normal = dyn_cast<BasicBlock>($8);
- BasicBlock *Except = dyn_cast<BasicBlock>($10);
-
- if (Normal == 0 || Except == 0)
- ThrowException("Invoke instruction without label destinations!");
+ BasicBlock *Normal = getBBVal($9);
+ BasicBlock *Except = getBBVal($12);
// Create the call node...
if (!$5) { // Has no arguments?
// Loop through FunctionType's arguments and ensure they are specified
// correctly!
//
- FunctionType::ParamTypes::const_iterator I = Ty->getParamTypes().begin();
- FunctionType::ParamTypes::const_iterator E = Ty->getParamTypes().end();
+ FunctionType::param_iterator I = Ty->param_begin();
+ FunctionType::param_iterator E = Ty->param_end();
std::vector<Value*>::iterator ArgI = $5->begin(), ArgE = $5->end();
for (; ArgI != ArgE && I != E; ++ArgI, ++I)
- if ((*ArgI)->getType() != *I)
- ThrowException("Parameter " +(*ArgI)->getName()+ " is not of type '" +
- (*I)->getDescription() + "'!");
+ if ((*ArgI)->getType() != *I)
+ ThrowException("Parameter " +(*ArgI)->getName()+ " is not of type '" +
+ (*I)->getDescription() + "'!");
if (I != E || (ArgI != ArgE && !Ty->isVarArg()))
- ThrowException("Invalid number of parameters detected!");
+ ThrowException("Invalid number of parameters detected!");
$$ = new InvokeInst(V, Normal, Except, *$5);
}
+ delete $2;
delete $5;
}
| UNWIND {
if (V == 0)
ThrowException("May only switch on a constant pool value!");
- $$->push_back(std::make_pair(V, cast<BasicBlock>(getVal($5, $6))));
+ $$->push_back(std::make_pair(V, getBBVal($6)));
}
| IntType ConstValueRef ',' LABEL ValueRef {
$$ = new std::vector<std::pair<Constant*, BasicBlock*> >();
if (V == 0)
ThrowException("May only switch on a constant pool value!");
- $$->push_back(std::make_pair(V, cast<BasicBlock>(getVal($4, $5))));
+ $$->push_back(std::make_pair(V, getBBVal($5)));
};
Inst : OptAssign InstVal {
// Is this definition named?? if so, assign the name...
- if (setValueName($2, $1)) { assert(0 && "No redefin allowed!"); }
+ setValueName($2, $1);
InsertValue($2);
$$ = $2;
};
PHIList : Types '[' ValueRef ',' ValueRef ']' { // Used for PHI nodes
$$ = new std::list<std::pair<Value*, BasicBlock*> >();
- $$->push_back(std::make_pair(getVal(*$1, $3),
- cast<BasicBlock>(getVal(Type::LabelTy, $5))));
+ $$->push_back(std::make_pair(getVal(*$1, $3), getBBVal($5)));
delete $1;
}
| PHIList ',' '[' ValueRef ',' ValueRef ']' {
$$ = $1;
$1->push_back(std::make_pair(getVal($1->front().first->getType(), $4),
- cast<BasicBlock>(getVal(Type::LabelTy, $6))));
+ getBBVal($6)));
};
| ShiftOps ResolvedVal ',' ResolvedVal {
if ($4->getType() != Type::UByteTy)
ThrowException("Shift amount must be ubyte!");
+ if (!$2->getType()->isInteger())
+ ThrowException("Shift constant expression requires integer operand!");
$$ = new ShiftInst($1, $2, $4);
}
| CAST ResolvedVal TO Types {
$$ = new CastInst($2, *$4);
delete $4;
}
+ | SELECT ResolvedVal ',' ResolvedVal ',' ResolvedVal {
+ if ($2->getType() != Type::BoolTy)
+ ThrowException("select condition must be boolean!");
+ if ($4->getType() != $6->getType())
+ ThrowException("select value types should match!");
+ $$ = new SelectInst($2, $4, $6);
+ }
| VA_ARG ResolvedVal ',' Types {
- $$ = new VarArgInst($2, *$4);
+ // 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 {
+ $$ = new VAArgInst($2, *$4);
+ delete $4;
+ }
+ | VANEXT ResolvedVal ',' Types {
+ $$ = new VANextInst($2, *$4);
delete $4;
}
- | PHI PHIList {
+ | 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);
while ($2->begin() != $2->end()) {
if ($2->front().first->getType() != Ty)
- ThrowException("All elements of a PHI node must be of the same type!");
+ ThrowException("All elements of a PHI node must be of the same type!");
cast<PHINode>($$)->addIncoming($2->front().first, $2->front().second);
$2->pop_front();
}
Ty = FunctionType::get($2->get(), ParamTypes, isVarArg);
PFTy = PointerType::get(Ty);
}
- delete $2;
Value *V = getVal(PFTy, $3); // Get the function we're calling...
// Loop through FunctionType's arguments and ensure they are specified
// correctly!
//
- FunctionType::ParamTypes::const_iterator I = Ty->getParamTypes().begin();
- FunctionType::ParamTypes::const_iterator E = Ty->getParamTypes().end();
+ FunctionType::param_iterator I = Ty->param_begin();
+ FunctionType::param_iterator E = Ty->param_end();
std::vector<Value*>::iterator ArgI = $5->begin(), ArgE = $5->end();
for (; ArgI != ArgE && I != E; ++ArgI, ++I)
- if ((*ArgI)->getType() != *I)
- ThrowException("Parameter " +(*ArgI)->getName()+ " is not of type '" +
- (*I)->getDescription() + "'!");
+ if ((*ArgI)->getType() != *I)
+ ThrowException("Parameter " +(*ArgI)->getName()+ " is not of type '" +
+ (*I)->getDescription() + "'!");
if (I != E || (ArgI != ArgE && !Ty->isVarArg()))
- ThrowException("Invalid number of parameters detected!");
+ ThrowException("Invalid number of parameters detected!");
$$ = new CallInst(V, *$5);
}
+ delete $2;
delete $5;
}
| MemoryInst {
| OptVolatile LOAD Types ValueRef {
if (!isa<PointerType>($3->get()))
ThrowException("Can't load from nonpointer type: " +
- (*$3)->getDescription());
+ (*$3)->getDescription());
$$ = new LoadInst(getVal(*$3, $4), "", $1);
delete $3;
}
| GETELEMENTPTR Types ValueRef IndexList {
if (!isa<PointerType>($2->get()))
ThrowException("getelementptr insn requires pointer operand!");
+
+ // LLVM 1.2 and earlier used ubyte struct indices. Convert any ubyte struct
+ // indices to uint struct indices for compatibility.
+ generic_gep_type_iterator<std::vector<Value*>::iterator>
+ GTI = gep_type_begin($2->get(), $4->begin(), $4->end()),
+ GTE = gep_type_end($2->get(), $4->begin(), $4->end());
+ for (unsigned i = 0, e = $4->size(); i != e && GTI != GTE; ++i, ++GTI)
+ if (isa<StructType>(*GTI)) // Only change struct indices
+ if (ConstantUInt *CUI = dyn_cast<ConstantUInt>((*$4)[i]))
+ if (CUI->getType() == Type::UByteTy)
+ (*$4)[i] = ConstantExpr::getCast(CUI, Type::UIntTy);
+
if (!GetElementPtrInst::getIndexedType(*$2, *$4, true))
- ThrowException("Can't get element ptr '" + (*$2)->getDescription()+ "'!");
+ ThrowException("Invalid getelementptr indices for type '" +
+ (*$2)->getDescription()+ "'!");
$$ = new GetElementPtrInst(getVal(*$2, $3), *$4);
delete $2; delete $4;
};
+
%%
int yyerror(const char *ErrorMsg) {
std::string where
= std::string((CurFilename == "-") ? std::string("<stdin>") : CurFilename)
+ ":" + utostr((unsigned) llvmAsmlineno) + ": ";
std::string errMsg = std::string(ErrorMsg) + "\n" + where + " while reading ";
- if (yychar == YYEMPTY)
+ if (yychar == YYEMPTY || yychar == 0)
errMsg += "end-of-file.";
else
errMsg += "token: '" + std::string(llvmAsmtext, llvmAsmleng) + "'";
projects / oota-llvm.git / blobdiff