bool LLParser::ParseMDString(MetadataBase *&MDS) {
std::string Str;
if (ParseStringConstant(Str)) return true;
- MDS = Context.getMDString(Str);
+ MDS = MDString::get(Context, Str);
return false;
}
// Create MDNode forward reference
SmallVector<Value *, 1> Elts;
std::string FwdRefName = "llvm.mdnode.fwdref." + utostr(MID);
- Elts.push_back(Context.getMDString(FwdRefName));
- MDNode *FwdNode = Context.getMDNode(Elts.data(), Elts.size());
+ Elts.push_back(MDString::get(Context, FwdRefName));
+ MDNode *FwdNode = MDNode::get(Context, Elts.data(), Elts.size());
ForwardRefMDNodes[MID] = std::make_pair(FwdNode, Lex.getLoc());
Node = FwdNode;
return false;
if (ParseToken(lltok::rbrace, "expected end of metadata node"))
return true;
- NamedMDNode::Create(Name.c_str(), Name.length(),
- Elts.data(), Elts.size(), M);
+ NamedMDNode::Create(Name, Elts.data(), Elts.size(), M);
return false;
}
|| ParseToken(lltok::rbrace, "expected end of metadata node"))
return true;
- MDNode *Init = Context.getMDNode(Elts.data(), Elts.size());
+ MDNode *Init = MDNode::get(Context, Elts.data(), Elts.size());
MetadataCache[MetadataID] = Init;
std::map<unsigned, std::pair<MetadataBase *, LocTy> >::iterator
FI = ForwardRefMDNodes.find(MetadataID);
break;
case lltok::kw_opaque:
// TypeRec ::= 'opaque'
- Result = Context.getOpaqueType();
+ Result = OpaqueType::get();
Lex.Lex();
break;
case lltok::lbrace:
if (const Type *T = M->getTypeByName(Lex.getStrVal())) {
Result = T;
} else {
- Result = Context.getOpaqueType();
+ Result = OpaqueType::get();
ForwardRefTypes.insert(std::make_pair(Lex.getStrVal(),
std::make_pair(Result,
Lex.getLoc())));
if (I != ForwardRefTypeIDs.end())
Result = I->second.first;
else {
- Result = Context.getOpaqueType();
+ Result = OpaqueType::get();
ForwardRefTypeIDs.insert(std::make_pair(Lex.getUIntVal(),
std::make_pair(Result,
Lex.getLoc())));
Lex.Lex();
unsigned Val;
if (ParseUInt32(Val)) return true;
- OpaqueType *OT = Context.getOpaqueType(); //Use temporary placeholder.
+ OpaqueType *OT = OpaqueType::get(); //Use temporary placeholder.
UpRefs.push_back(UpRefRecord(Lex.getLoc(), Val, OT));
Result = OT;
break;
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(Context.getPointerTypeUnqual(Result.get()));
+ Result = HandleUpRefs(PointerType::getUnqual(Result.get()));
Lex.Lex();
break;
ParseToken(lltok::star, "expected '*' in address space"))
return true;
- Result = HandleUpRefs(Context.getPointerType(Result.get(), AddrSpace));
+ Result = HandleUpRefs(PointerType::get(Result.get(), AddrSpace));
break;
}
for (unsigned i = 0, e = ArgList.size(); i != e; ++i)
ArgListTy.push_back(ArgList[i].Type);
- Result = HandleUpRefs(Context.getFunctionType(Result.get(),
+ Result = HandleUpRefs(FunctionType::get(Result.get(),
ArgListTy, isVarArg));
return false;
}
Lex.Lex(); // Consume the '{'
if (EatIfPresent(lltok::rbrace)) {
- Result = Context.getStructType(Packed);
+ Result = StructType::get(Packed);
return false;
}
std::vector<const Type*> ParamsListTy;
for (unsigned i = 0, e = ParamsList.size(); i != e; ++i)
ParamsListTy.push_back(ParamsList[i].get());
- Result = HandleUpRefs(Context.getStructType(ParamsListTy, Packed));
+ Result = HandleUpRefs(StructType::get(ParamsListTy, Packed));
return false;
}
return Error(SizeLoc, "size too large for vector");
if (!VectorType::isValidElementType(EltTy))
return Error(TypeLoc, "vector element type must be fp or integer");
- Result = Context.getVectorType(EltTy, unsigned(Size));
+ Result = VectorType::get(EltTy, unsigned(Size));
} else {
if (!ArrayType::isValidElementType(EltTy))
return Error(TypeLoc, "invalid array element type");
- Result = HandleUpRefs(Context.getArrayType(EltTy, Size));
+ Result = HandleUpRefs(ArrayType::get(EltTy, Size));
}
return false;
}
I = ForwardRefVals.begin(), E = ForwardRefVals.end(); I != E; ++I)
if (!isa<BasicBlock>(I->second.first)) {
I->second.first->replaceAllUsesWith(
- P.getContext().getUndef(I->second.first->getType()));
+ UndefValue::get(I->second.first->getType()));
delete I->second.first;
I->second.first = 0;
}
I = ForwardRefValIDs.begin(), E = ForwardRefValIDs.end(); I != E; ++I)
if (!isa<BasicBlock>(I->second.first)) {
I->second.first->replaceAllUsesWith(
- P.getContext().getUndef(I->second.first->getType()));
+ UndefValue::get(I->second.first->getType()));
delete I->second.first;
I->second.first = 0;
}
ParseToken(lltok::rbrace, "expected end of metadata node"))
return true;
- ID.MetadataVal = Context.getMDNode(Elts.data(), Elts.size());
+ ID.MetadataVal = MDNode::get(Context, Elts.data(), Elts.size());
return false;
}
ID.Kind = ValID::t_APFloat;
break;
case lltok::kw_true:
- ID.ConstantVal = Context.getTrue();
+ ID.ConstantVal = ConstantInt::getTrue(Context);
ID.Kind = ValID::t_Constant;
break;
case lltok::kw_false:
- ID.ConstantVal = Context.getFalse();
+ ID.ConstantVal = ConstantInt::getFalse(Context);
ID.Kind = ValID::t_Constant;
break;
case lltok::kw_null: ID.Kind = ValID::t_Null; break;
return Error(FirstEltLoc, "invalid array element type: " +
Elts[0]->getType()->getDescription());
- ArrayType *ATy = Context.getArrayType(Elts[0]->getType(), Elts.size());
+ ArrayType *ATy = ArrayType::get(Elts[0]->getType(), Elts.size());
// Verify all elements are correct type!
for (unsigned i = 0, e = Elts.size(); i != e; ++i) {
case ValID::t_Null:
if (!isa<PointerType>(Ty))
return Error(ID.Loc, "null must be a pointer type");
- V = Con
text.getConstantPointerNull(cast<PointerType>(Ty));
+ V = Con
stantPointerNull::get(cast<PointerType>(Ty));
return false;
case ValID::t_Undef:
// FIXME: LabelTy should not be a first-class type.
if ((!Ty->isFirstClassType() || Ty == Type::LabelTy) &&
!isa<OpaqueType>(Ty))
return Error(ID.Loc, "invalid type for undef constant");
- V = Context.getUndef(Ty);
+ V = UndefValue::get(Ty);
return false;
case ValID::t_EmptyArray:
if (!isa<ArrayType>(Ty) || cast<ArrayType>(Ty)->getNumElements() != 0)
return Error(ID.Loc, "invalid empty array initializer");
- V = Context.getUndef(Ty);
+ V = UndefValue::get(Ty);
return false;
case ValID::t_Zero:
// 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 = Context.getNullValue(Ty);
+ V = Constant::getNullValue(Ty);
return false;
case ValID::t_Constant:
if (ID.ConstantVal->getType() != Ty)
return Error(RetTypeLoc, "functions with 'sret' argument must return void");
const FunctionType *FT =
- Context.getFunctionType(RetType, ParamTypeList, isVarArg);
- const PointerType *PFT = Context.getPointerTypeUnqual(FT);
+ FunctionType::get(RetType, ParamTypeList, isVarArg);
+ const PointerType *PFT = PointerType::getUnqual(FT);
Fn = 0;
if (!FunctionName.empty()) {
RVs.push_back(RV);
}
- RV = Context.getUndef(PFS.getFunction().getReturnType());
+ RV = UndefValue::get(PFS.getFunction().getReturnType());
for (unsigned i = 0, e = RVs.size(); i != e; ++i) {
Instruction *I = InsertValueInst::Create(RV, RVs[i], i, "mrv");
BB->getInstList().push_back(I);
if (!FunctionType::isValidReturnType(RetType))
return Error(RetTypeLoc, "Invalid result type for LLVM function");
- Ty = Context.getFunctionType(RetType, ParamTypes, false);
- PFTy = Context.getPointerTypeUnqual(Ty);
+ Ty = FunctionType::get(RetType, ParamTypes, false);
+ PFTy = PointerType::getUnqual(Ty);
}
// Look up the callee.
if (!FunctionType::isValidReturnType(RetType))
return Error(RetTypeLoc, "Invalid result type for LLVM function");
- Ty = Context.getFunctionType(RetType, ParamTypes, false);
- PFTy = Context.getPointerTypeUnqual(Ty);
+ Ty = FunctionType::get(RetType, ParamTypes, false);
+ PFTy = PointerType::getUnqual(Ty);
}
// Look up the callee.
projects / oota-llvm.git / blobdiff