Try again at converting the LLParser to use LLVMContext, without massive breakage this time.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@74671 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Owen Anderson 2009-07-01 23:57:11 +00:00
parent 7f41781c3b
commit fba933c823
2 changed files with 55 additions and 47 deletions

View File

@ -18,6 +18,7 @@
#include "llvm/DerivedTypes.h"
#include "llvm/InlineAsm.h"
#include "llvm/Instructions.h"
#include "llvm/LLVMContext.h"
#include "llvm/MDNode.h"
#include "llvm/Module.h"
#include "llvm/ValueSymbolTable.h"
@ -997,7 +998,7 @@ bool LLParser::ParseTypeRec(PATypeHolder &Result) {
break;
case lltok::kw_opaque:
// TypeRec ::= 'opaque'
Result = OpaqueType::get();
Result = Context.getOpaqueType();
Lex.Lex();
break;
case lltok::lbrace:
@ -1027,7 +1028,7 @@ bool LLParser::ParseTypeRec(PATypeHolder &Result) {
if (const Type *T = M->getTypeByName(Lex.getStrVal())) {
Result = T;
} else {
Result = OpaqueType::get();
Result = Context.getOpaqueType();
ForwardRefTypes.insert(std::make_pair(Lex.getStrVal(),
std::make_pair(Result,
Lex.getLoc())));
@ -1046,7 +1047,7 @@ bool LLParser::ParseTypeRec(PATypeHolder &Result) {
if (I != ForwardRefTypeIDs.end())
Result = I->second.first;
else {
Result = OpaqueType::get();
Result = Context.getOpaqueType();
ForwardRefTypeIDs.insert(std::make_pair(Lex.getUIntVal(),
std::make_pair(Result,
Lex.getLoc())));
@ -1059,7 +1060,7 @@ bool LLParser::ParseTypeRec(PATypeHolder &Result) {
Lex.Lex();
unsigned Val;
if (ParseUInt32(Val)) return true;
OpaqueType *OT = OpaqueType::get(); // Use temporary placeholder.
OpaqueType *OT = Context.getOpaqueType(); //Use temporary placeholder.
UpRefs.push_back(UpRefRecord(Lex.getLoc(), Val, OT));
Result = OT;
break;
@ -1080,7 +1081,7 @@ bool LLParser::ParseTypeRec(PATypeHolder &Result) {
return TokError("pointers to void are invalid; use i8* instead");
if (!PointerType::isValidElementType(Result.get()))
return TokError("pointer to this type is invalid");
Result = HandleUpRefs(PointerType::getUnqual(Result.get()));
Result = HandleUpRefs(Context.getPointerTypeUnqual(Result.get()));
Lex.Lex();
break;
@ -1097,7 +1098,7 @@ bool LLParser::ParseTypeRec(PATypeHolder &Result) {
ParseToken(lltok::star, "expected '*' in address space"))
return true;
Result = HandleUpRefs(PointerType::get(Result.get(), AddrSpace));
Result = HandleUpRefs(Context.getPointerType(Result.get(), AddrSpace));
break;
}
@ -1258,7 +1259,8 @@ bool LLParser::ParseFunctionType(PATypeHolder &Result) {
for (unsigned i = 0, e = ArgList.size(); i != e; ++i)
ArgListTy.push_back(ArgList[i].Type);
Result = HandleUpRefs(FunctionType::get(Result.get(), ArgListTy, isVarArg));
Result = HandleUpRefs(Context.getFunctionType(Result.get(),
ArgListTy, isVarArg));
return false;
}
@ -1273,7 +1275,7 @@ bool LLParser::ParseStructType(PATypeHolder &Result, bool Packed) {
Lex.Lex(); // Consume the '{'
if (EatIfPresent(lltok::rbrace)) {
Result = StructType::get(Packed);
Result = Context.getStructType(Packed);
return false;
}
@ -1305,7 +1307,7 @@ bool LLParser::ParseStructType(PATypeHolder &Result, bool Packed) {
std::vector<const Type*> ParamsListTy;
for (unsigned i = 0, e = ParamsList.size(); i != e; ++i)
ParamsListTy.push_back(ParamsList[i].get());
Result = HandleUpRefs(StructType::get(ParamsListTy, Packed));
Result = HandleUpRefs(Context.getStructType(ParamsListTy, Packed));
return false;
}
@ -1344,11 +1346,11 @@ bool LLParser::ParseArrayVectorType(PATypeHolder &Result, bool isVector) {
return Error(SizeLoc, "size too large for vector");
if (!VectorType::isValidElementType(EltTy))
return Error(TypeLoc, "vector element type must be fp or integer");
Result = VectorType::get(EltTy, unsigned(Size));
Result = Context.getVectorType(EltTy, unsigned(Size));
} else {
if (!ArrayType::isValidElementType(EltTy))
return Error(TypeLoc, "invalid array element type");
Result = HandleUpRefs(ArrayType::get(EltTy, Size));
Result = HandleUpRefs(Context.getArrayType(EltTy, Size));
}
return false;
}
@ -1653,11 +1655,11 @@ bool LLParser::ParseValID(ValID &ID) {
ID.Kind = ValID::t_APFloat;
break;
case lltok::kw_true:
ID.ConstantVal = ConstantInt::getTrue();
ID.ConstantVal = Context.getConstantIntTrue();
ID.Kind = ValID::t_Constant;
break;
case lltok::kw_false:
ID.ConstantVal = ConstantInt::getFalse();
ID.ConstantVal = Context.getConstantIntFalse();
ID.Kind = ValID::t_Constant;
break;
case lltok::kw_null: ID.Kind = ValID::t_Null; break;
@ -1672,7 +1674,7 @@ bool LLParser::ParseValID(ValID &ID) {
ParseToken(lltok::rbrace, "expected end of struct constant"))
return true;
ID.ConstantVal = ConstantStruct::get(Elts.data(), Elts.size(), false);
ID.ConstantVal = Context.getConstantStruct(Elts.data(), Elts.size(), false);
ID.Kind = ValID::t_Constant;
return false;
}
@ -1691,7 +1693,8 @@ bool LLParser::ParseValID(ValID &ID) {
return true;
if (isPackedStruct) {
ID.ConstantVal = ConstantStruct::get(Elts.data(), Elts.size(), true);
ID.ConstantVal =
Context.getConstantStruct(Elts.data(), Elts.size(), true);
ID.Kind = ValID::t_Constant;
return false;
}
@ -1711,7 +1714,7 @@ bool LLParser::ParseValID(ValID &ID) {
"vector element #" + utostr(i) +
" is not of type '" + Elts[0]->getType()->getDescription());
ID.ConstantVal = ConstantVector::get(Elts.data(), Elts.size());
ID.ConstantVal = Context.getConstantVector(Elts.data(), Elts.size());
ID.Kind = ValID::t_Constant;
return false;
}
@ -1735,7 +1738,7 @@ bool LLParser::ParseValID(ValID &ID) {
return Error(FirstEltLoc, "invalid array element type: " +
Elts[0]->getType()->getDescription());
ArrayType *ATy = ArrayType::get(Elts[0]->getType(), Elts.size());
ArrayType *ATy = Context.getArrayType(Elts[0]->getType(), Elts.size());
// Verify all elements are correct type!
for (unsigned i = 0, e = Elts.size(); i != e; ++i) {
@ -1745,13 +1748,13 @@ bool LLParser::ParseValID(ValID &ID) {
" is not of type '" +Elts[0]->getType()->getDescription());
}
ID.ConstantVal = ConstantArray::get(ATy, Elts.data(), Elts.size());
ID.ConstantVal = Context.getConstantArray(ATy, Elts.data(), Elts.size());
ID.Kind = ValID::t_Constant;
return false;
}
case lltok::kw_c: // c "foo"
Lex.Lex();
ID.ConstantVal = ConstantArray::get(Lex.getStrVal(), false);
ID.ConstantVal = Context.getConstantArray(Lex.getStrVal(), false);
if (ParseToken(lltok::StringConstant, "expected string")) return true;
ID.Kind = ValID::t_Constant;
return false;
@ -1797,8 +1800,8 @@ bool LLParser::ParseValID(ValID &ID) {
return Error(ID.Loc, "invalid cast opcode for cast from '" +
SrcVal->getType()->getDescription() + "' to '" +
DestTy->getDescription() + "'");
ID.ConstantVal = ConstantExpr::getCast((Instruction::CastOps)Opc, SrcVal,
DestTy);
ID.ConstantVal = Context.getConstantExprCast((Instruction::CastOps)Opc,
SrcVal, DestTy);
ID.Kind = ValID::t_Constant;
return false;
}
@ -1817,7 +1820,7 @@ bool LLParser::ParseValID(ValID &ID) {
Indices.end()))
return Error(ID.Loc, "invalid indices for extractvalue");
ID.ConstantVal =
ConstantExpr::getExtractValue(Val, Indices.data(), Indices.size());
Context.getConstantExprExtractValue(Val, Indices.data(), Indices.size());
ID.Kind = ValID::t_Constant;
return false;
}
@ -1837,8 +1840,8 @@ bool LLParser::ParseValID(ValID &ID) {
if (!ExtractValueInst::getIndexedType(Val0->getType(), Indices.begin(),
Indices.end()))
return Error(ID.Loc, "invalid indices for insertvalue");
ID.ConstantVal =
ConstantExpr::getInsertValue(Val0, Val1, Indices.data(), Indices.size());
ID.ConstantVal = Context.getConstantExprInsertValue(Val0, Val1,
Indices.data(), Indices.size());
ID.Kind = ValID::t_Constant;
return false;
}
@ -1865,24 +1868,24 @@ bool LLParser::ParseValID(ValID &ID) {
if (Opc == Instruction::FCmp) {
if (!Val0->getType()->isFPOrFPVector())
return Error(ID.Loc, "fcmp requires floating point operands");
ID.ConstantVal = ConstantExpr::getFCmp(Pred, Val0, Val1);
ID.ConstantVal = Context.getConstantExprFCmp(Pred, Val0, Val1);
} else if (Opc == Instruction::ICmp) {
if (!Val0->getType()->isIntOrIntVector() &&
!isa<PointerType>(Val0->getType()))
return Error(ID.Loc, "icmp requires pointer or integer operands");
ID.ConstantVal = ConstantExpr::getICmp(Pred, Val0, Val1);
ID.ConstantVal = Context.getConstantExprICmp(Pred, Val0, Val1);
} else if (Opc == Instruction::VFCmp) {
// FIXME: REMOVE VFCMP Support
if (!Val0->getType()->isFPOrFPVector() ||
!isa<VectorType>(Val0->getType()))
return Error(ID.Loc, "vfcmp requires vector floating point operands");
ID.ConstantVal = ConstantExpr::getVFCmp(Pred, Val0, Val1);
ID.ConstantVal = Context.getConstantExprVFCmp(Pred, Val0, Val1);
} else if (Opc == Instruction::VICmp) {
// FIXME: REMOVE VICMP Support
if (!Val0->getType()->isIntOrIntVector() ||
!isa<VectorType>(Val0->getType()))
return Error(ID.Loc, "vicmp requires vector floating point operands");
ID.ConstantVal = ConstantExpr::getVICmp(Pred, Val0, Val1);
ID.ConstantVal = Context.getConstantExprVICmp(Pred, Val0, Val1);
}
ID.Kind = ValID::t_Constant;
return false;
@ -1915,7 +1918,7 @@ bool LLParser::ParseValID(ValID &ID) {
if (!Val0->getType()->isIntOrIntVector() &&
!Val0->getType()->isFPOrFPVector())
return Error(ID.Loc,"constexpr requires integer, fp, or vector operands");
ID.ConstantVal = ConstantExpr::get(Opc, Val0, Val1);
ID.ConstantVal = Context.getConstantExpr(Opc, Val0, Val1);
ID.Kind = ValID::t_Constant;
return false;
}
@ -1941,7 +1944,7 @@ bool LLParser::ParseValID(ValID &ID) {
if (!Val0->getType()->isIntOrIntVector())
return Error(ID.Loc,
"constexpr requires integer or integer vector operands");
ID.ConstantVal = ConstantExpr::get(Opc, Val0, Val1);
ID.ConstantVal = Context.getConstantExpr(Opc, Val0, Val1);
ID.Kind = ValID::t_Constant;
return false;
}
@ -1966,7 +1969,7 @@ bool LLParser::ParseValID(ValID &ID) {
if (!GetElementPtrInst::getIndexedType(Elts[0]->getType(),
(Value**)&Elts[1], Elts.size()-1))
return Error(ID.Loc, "invalid indices for getelementptr");
ID.ConstantVal = ConstantExpr::getGetElementPtr(Elts[0],
ID.ConstantVal = Context.getConstantExprGetElementPtr(Elts[0],
&Elts[1], Elts.size()-1);
} else if (Opc == Instruction::Select) {
if (Elts.size() != 3)
@ -1974,26 +1977,28 @@ bool LLParser::ParseValID(ValID &ID) {
if (const char *Reason = SelectInst::areInvalidOperands(Elts[0], Elts[1],
Elts[2]))
return Error(ID.Loc, Reason);
ID.ConstantVal = ConstantExpr::getSelect(Elts[0], Elts[1], Elts[2]);
ID.ConstantVal = Context.getConstantExprSelect(Elts[0], Elts[1], Elts[2]);
} else if (Opc == Instruction::ShuffleVector) {
if (Elts.size() != 3)
return Error(ID.Loc, "expected three operands to shufflevector");
if (!ShuffleVectorInst::isValidOperands(Elts[0], Elts[1], Elts[2]))
return Error(ID.Loc, "invalid operands to shufflevector");
ID.ConstantVal = ConstantExpr::getShuffleVector(Elts[0], Elts[1],Elts[2]);
ID.ConstantVal =
Context.getConstantExprShuffleVector(Elts[0], Elts[1],Elts[2]);
} else if (Opc == Instruction::ExtractElement) {
if (Elts.size() != 2)
return Error(ID.Loc, "expected two operands to extractelement");
if (!ExtractElementInst::isValidOperands(Elts[0], Elts[1]))
return Error(ID.Loc, "invalid extractelement operands");
ID.ConstantVal = ConstantExpr::getExtractElement(Elts[0], Elts[1]);
ID.ConstantVal = Context.getConstantExprExtractElement(Elts[0], Elts[1]);
} else {
assert(Opc == Instruction::InsertElement && "Unknown opcode");
if (Elts.size() != 3)
return Error(ID.Loc, "expected three operands to insertelement");
if (!InsertElementInst::isValidOperands(Elts[0], Elts[1], Elts[2]))
return Error(ID.Loc, "invalid insertelement operands");
ID.ConstantVal = ConstantExpr::getInsertElement(Elts[0], Elts[1],Elts[2]);
ID.ConstantVal =
Context.getConstantExprInsertElement(Elts[0], Elts[1],Elts[2]);
}
ID.Kind = ValID::t_Constant;
@ -2037,7 +2042,7 @@ bool LLParser::ConvertGlobalValIDToValue(const Type *Ty, ValID &ID,
if (!isa<IntegerType>(Ty))
return Error(ID.Loc, "integer constant must have integer type");
ID.APSIntVal.extOrTrunc(Ty->getPrimitiveSizeInBits());
V = ConstantInt::get(ID.APSIntVal);
V = Context.getConstantInt(ID.APSIntVal);
return false;
case ValID::t_APFloat:
if (!Ty->isFloatingPoint() ||
@ -2052,7 +2057,7 @@ bool LLParser::ConvertGlobalValIDToValue(const Type *Ty, ValID &ID,
ID.APFloatVal.convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven,
&Ignored);
}
V = ConstantFP::get(ID.APFloatVal);
V = Context.getConstantFP(ID.APFloatVal);
if (V->getType() != Ty)
return Error(ID.Loc, "floating point constant does not have type '" +
@ -2062,7 +2067,7 @@ bool LLParser::ConvertGlobalValIDToValue(const Type *Ty, ValID &ID,
case ValID::t_Null:
if (!isa<PointerType>(Ty))
return Error(ID.Loc, "null must be a pointer type");
V = ConstantPointerNull::get(cast<PointerType>(Ty));
V = Context.getConstantPointerNull(cast<PointerType>(Ty));
return false;
case ValID::t_Undef:
// FIXME: LabelTy should not be a first-class type.
@ -2080,7 +2085,7 @@ bool LLParser::ConvertGlobalValIDToValue(const Type *Ty, ValID &ID,
// FIXME: LabelTy should not be a first-class type.
if (!Ty->isFirstClassType() || Ty == Type::LabelTy)
return Error(ID.Loc, "invalid type for null constant");
V = Constant::getNullValue(Ty);
V = Context.getNullValue(Ty);
return false;
case ValID::t_Constant:
if (ID.ConstantVal->getType() != Ty)
@ -2282,8 +2287,9 @@ bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
RetType != Type::VoidTy)
return Error(RetTypeLoc, "functions with 'sret' argument must return void");
const FunctionType *FT = FunctionType::get(RetType, ParamTypeList, isVarArg);
const PointerType *PFT = PointerType::getUnqual(FT);
const FunctionType *FT =
Context.getFunctionType(RetType, ParamTypeList, isVarArg);
const PointerType *PFT = Context.getPointerTypeUnqual(FT);
Fn = 0;
if (!FunctionName.empty()) {
@ -2736,8 +2742,8 @@ bool LLParser::ParseInvoke(Instruction *&Inst, PerFunctionState &PFS) {
if (!FunctionType::isValidReturnType(RetType))
return Error(RetTypeLoc, "Invalid result type for LLVM function");
Ty = FunctionType::get(RetType, ParamTypes, false);
PFTy = PointerType::getUnqual(Ty);
Ty = Context.getFunctionType(RetType, ParamTypes, false);
PFTy = Context.getPointerTypeUnqual(Ty);
}
// Look up the callee.
@ -3085,8 +3091,8 @@ bool LLParser::ParseCall(Instruction *&Inst, PerFunctionState &PFS,
if (!FunctionType::isValidReturnType(RetType))
return Error(RetTypeLoc, "Invalid result type for LLVM function");
Ty = FunctionType::get(RetType, ParamTypes, false);
PFTy = PointerType::getUnqual(Ty);
Ty = Context.getFunctionType(RetType, ParamTypes, false);
PFTy = Context.getPointerTypeUnqual(Ty);
}
// Look up the callee.

View File

@ -15,6 +15,7 @@
#define LLVM_ASMPARSER_LLPARSER_H
#include "LLLexer.h"
#include "llvm/Module.h"
#include "llvm/Type.h"
#include <map>
@ -35,7 +36,7 @@ namespace llvm {
public:
typedef LLLexer::LocTy LocTy;
private:
LLVMContext& Context;
LLLexer Lex;
Module *M;
@ -72,7 +73,8 @@ namespace llvm {
std::map<unsigned, std::pair<GlobalValue*, LocTy> > ForwardRefValIDs;
std::vector<GlobalValue*> NumberedVals;
public:
LLParser(MemoryBuffer *F, ParseError &Err, Module *m) : Lex(F, Err), M(m) {}
LLParser(MemoryBuffer *F, ParseError &Err, Module *m) :
Context(m->getContext()), Lex(F, Err), M(m) {}
bool Run();
private: