#include "llvm/ADT/STLExtras.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/Streams.h"
-#include "llvm/ParamAttrsList.h"
#include <algorithm>
#include <list>
#include <map>
GenerateError("FP constant invalid for type");
return 0;
}
- // Lexer has no type info, so builds all float and double FP constants
+ // Lexer has no type info, so builds all float and double FP constants
// as double. Fix this here. Long double does not need this.
if (&D.ConstPoolFP->getSemantics() == &APFloat::IEEEdouble &&
Ty==Type::FloatTy)
D.ConstPoolFP->convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven);
- return ConstantFP::get(Ty, *D.ConstPoolFP);
+ return ConstantFP::get(*D.ConstPoolFP);
case ValID::ConstNullVal: // Is it a null value?
if (!isa<PointerType>(Ty)) {
}
const Type* ElTy = PTy->getElementType();
if (const FunctionType *FTy = dyn_cast<FunctionType>(ElTy))
- V = new Function(FTy, GlobalValue::ExternalLinkage);
+ V = Function::Create(FTy, GlobalValue::ExternalLinkage);
else
V = new GlobalVariable(ElTy, false, GlobalValue::ExternalLinkage, 0, "",
(Module*)0, false, PTy->getAddressSpace());
assert(ID.Num == CurFun.NextValNum && "Invalid new block number");
InsertValue(BB);
}
-
- ID.destroy();
- return BB;
- }
-
- // We haven't seen this BB before and its first mention is a definition.
- // Just create it and return it.
- std::string Name (ID.Type == ValID::LocalName ? ID.getName() : "");
- BB = new BasicBlock(Name, CurFun.CurrentFunction);
- if (ID.Type == ValID::LocalID) {
- assert(ID.Num == CurFun.NextValNum && "Invalid new block number");
- InsertValue(BB);
+ } else {
+ // We haven't seen this BB before and its first mention is a definition.
+ // Just create it and return it.
+ std::string Name (ID.Type == ValID::LocalName ? ID.getName() : "");
+ BB = BasicBlock::Create(Name, CurFun.CurrentFunction);
+ if (ID.Type == ValID::LocalID) {
+ assert(ID.Num == CurFun.NextValNum && "Invalid new block number");
+ InsertValue(BB);
+ }
}
- ID.destroy(); // Free strdup'd memory
+ ID.destroy();
return BB;
}
std::string Name;
if (ID.Type == ValID::LocalName)
Name = ID.getName();
- BB = new BasicBlock(Name, CurFun.CurrentFunction);
+ BB = BasicBlock::Create(Name, CurFun.CurrentFunction);
// Insert it in the forward refs map.
CurFun.BBForwardRefs[ID] = BB;
%token ZEROINITIALIZER TRUETOK FALSETOK BEGINTOK ENDTOK
%token DECLARE DEFINE GLOBAL CONSTANT SECTION ALIAS VOLATILE THREAD_LOCAL
%token TO DOTDOTDOT NULL_TOK UNDEF INTERNAL LINKONCE WEAK APPENDING
-%token DLLIMPORT DLLEXPORT EXTERN_WEAK
+%token DLLIMPORT DLLEXPORT EXTERN_WEAK COMMON
%token OPAQUE EXTERNAL TARGET TRIPLE ALIGN ADDRSPACE
%token DEPLIBS CALL TAIL ASM_TOK MODULE SIDEEFFECT
%token CC_TOK CCC_TOK FASTCC_TOK COLDCC_TOK X86_STDCALLCC_TOK X86_FASTCALLCC_TOK
%token <BinaryOpVal> ADD SUB MUL UDIV SDIV FDIV UREM SREM FREM AND OR XOR
%token <BinaryOpVal> SHL LSHR ASHR
-%token <OtherOpVal> ICMP FCMP
+%token <OtherOpVal> ICMP FCMP VICMP VFCMP
%type <IPredicate> IPredicates
%type <FPredicate> FPredicates
%token EQ NE SLT SGT SLE SGE ULT UGT ULE UGE
| LINKONCE { $$ = GlobalValue::LinkOnceLinkage; }
| APPENDING { $$ = GlobalValue::AppendingLinkage; }
| DLLEXPORT { $$ = GlobalValue::DLLExportLinkage; }
+ | COMMON { $$ = GlobalValue::CommonLinkage; }
;
GVExternalLinkage
| Types '(' ArgTypeListI ')' OptFuncAttrs {
// Allow but ignore attributes on function types; this permits auto-upgrade.
// FIXME: remove in LLVM 3.0.
- const Type* RetTy = *$1;
- if (!(RetTy->isFirstClassType() || RetTy == Type::VoidTy ||
- isa<OpaqueType>(RetTy)))
- GEN_ERROR("LLVM Functions cannot return aggregates");
-
+ const Type *RetTy = *$1;
+ if (!FunctionType::isValidReturnType(RetTy))
+ GEN_ERROR("Invalid result type for LLVM function");
+
std::vector<const Type*> Params;
TypeWithAttrsList::iterator I = $3->begin(), E = $3->end();
for (; I != E; ++I ) {
GlobalValue *GV;
if (const FunctionType *FTy =
dyn_cast<FunctionType>(PT->getElementType())) {
- GV = new Function(FTy, GlobalValue::ExternalWeakLinkage, Name,
- CurModule.CurrentModule);
+ GV = Function::Create(FTy, GlobalValue::ExternalWeakLinkage, Name,
+ CurModule.CurrentModule);
} else {
GV = new GlobalVariable(PT->getElementType(), false,
GlobalValue::ExternalWeakLinkage, 0,
// as double. Fix this here. Long double is done right.
if (&$2->getSemantics()==&APFloat::IEEEdouble && $1==Type::FloatTy)
$2->convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven);
- $$ = ConstantFP::get($1, *$2);
+ $$ = ConstantFP::get(*$2);
delete $2;
CHECK_FOR_ERROR
};
GEN_ERROR("GetElementPtr requires a pointer operand");
const Type *IdxTy =
- GetElementPtrInst::getIndexedType($3->getType(), $4->begin(), $4->end(),
- true);
+ GetElementPtrInst::getIndexedType($3->getType(), $4->begin(), $4->end());
if (!IdxTy)
GEN_ERROR("Index list invalid for constant getelementptr");
GEN_ERROR("fcmp operand types must match");
$$ = ConstantExpr::getFCmp($2, $4, $6);
}
+ | VICMP IPredicates '(' ConstVal ',' ConstVal ')' {
+ if ($4->getType() != $6->getType())
+ GEN_ERROR("vicmp operand types must match");
+ $$ = ConstantExpr::getVICmp($2, $4, $6);
+ }
+ | VFCMP FPredicates '(' ConstVal ',' ConstVal ')' {
+ if ($4->getType() != $6->getType())
+ GEN_ERROR("vfcmp operand types must match");
+ $$ = ConstantExpr::getVFCmp($2, $4, $6);
+ }
| EXTRACTELEMENT '(' ConstVal ',' ConstVal ')' {
if (!ExtractElementInst::isValidOperands($3, $5))
GEN_ERROR("Invalid extractelement operands");
if (!CurFun.isDeclare && CurModule.TypeIsUnresolved($2))
GEN_ERROR("Reference to abstract result: "+ $2->get()->getDescription());
+ if (!FunctionType::isValidReturnType(*$2))
+ GEN_ERROR("Invalid result type for LLVM function");
+
std::vector<const Type*> ParamTypeList;
- ParamAttrsVector Attrs;
- if ($7 != ParamAttr::None) {
- ParamAttrsWithIndex PAWI;
- PAWI.index = 0;
- PAWI.attrs = $7;
- Attrs.push_back(PAWI);
- }
+ SmallVector<ParamAttrsWithIndex, 8> Attrs;
+ if ($7 != ParamAttr::None)
+ Attrs.push_back(ParamAttrsWithIndex::get(0, $7));
if ($5) { // If there are arguments...
unsigned index = 1;
for (ArgListType::iterator I = $5->begin(); I != $5->end(); ++I, ++index) {
if (!CurFun.isDeclare && CurModule.TypeIsUnresolved(I->Ty))
GEN_ERROR("Reference to abstract argument: " + Ty->getDescription());
ParamTypeList.push_back(Ty);
- if (Ty != Type::VoidTy)
- if (I->Attrs != ParamAttr::None) {
- ParamAttrsWithIndex PAWI;
- PAWI.index = index;
- PAWI.attrs = I->Attrs;
- Attrs.push_back(PAWI);
- }
+ if (Ty != Type::VoidTy && I->Attrs != ParamAttr::None)
+ Attrs.push_back(ParamAttrsWithIndex::get(index, I->Attrs));
}
}
bool isVarArg = ParamTypeList.size() && ParamTypeList.back() == Type::VoidTy;
if (isVarArg) ParamTypeList.pop_back();
- const ParamAttrsList *PAL = 0;
+ PAListPtr PAL;
if (!Attrs.empty())
- PAL = ParamAttrsList::get(Attrs);
+ PAL = PAListPtr::get(Attrs.begin(), Attrs.end());
FunctionType *FT = FunctionType::get(*$2, ParamTypeList, isVarArg);
const PointerType *PFT = PointerType::getUnqual(FT);
// Move the function to the end of the list, from whereever it was
// previously inserted.
Fn = cast<Function>(FWRef);
- assert(!Fn->getParamAttrs() && "Forward reference has parameter attributes!");
+ assert(Fn->getParamAttrs().isEmpty() &&
+ "Forward reference has parameter attributes!");
CurModule.CurrentModule->getFunctionList().remove(Fn);
CurModule.CurrentModule->getFunctionList().push_back(Fn);
} else if (!FunctionName.empty() && // Merge with an earlier prototype?
AI->setName("");
}
} else { // Not already defined?
- Fn = new Function(FT, GlobalValue::ExternalWeakLinkage, FunctionName,
- CurModule.CurrentModule);
+ Fn = Function::Create(FT, GlobalValue::ExternalWeakLinkage, FunctionName,
+ CurModule.CurrentModule);
InsertValue(Fn, CurModule.Values);
}
RET ReturnedVal { // Return with a result...
ValueList &VL = *$2;
assert(!VL.empty() && "Invalid ret operands!");
- $$ = new ReturnInst(&VL[0], VL.size());
+ $$ = ReturnInst::Create(&VL[0], VL.size());
delete $2;
CHECK_FOR_ERROR
}
| RET VOID { // Return with no result...
- $$ = new ReturnInst();
+ $$ = ReturnInst::Create();
CHECK_FOR_ERROR
}
| BR LABEL ValueRef { // Unconditional Branch...
BasicBlock* tmpBB = getBBVal($3);
CHECK_FOR_ERROR
- $$ = new BranchInst(tmpBB);
+ $$ = BranchInst::Create(tmpBB);
} // Conditional Branch...
| BR INTTYPE ValueRef ',' LABEL ValueRef ',' LABEL ValueRef {
assert(cast<IntegerType>($2)->getBitWidth() == 1 && "Not Bool?");
CHECK_FOR_ERROR
Value* tmpVal = getVal(Type::Int1Ty, $3);
CHECK_FOR_ERROR
- $$ = new BranchInst(tmpBBA, tmpBBB, tmpVal);
+ $$ = BranchInst::Create(tmpBBA, tmpBBB, tmpVal);
}
| SWITCH IntType ValueRef ',' LABEL ValueRef '[' JumpTable ']' {
Value* tmpVal = getVal($2, $3);
CHECK_FOR_ERROR
BasicBlock* tmpBB = getBBVal($6);
CHECK_FOR_ERROR
- SwitchInst *S = new SwitchInst(tmpVal, tmpBB, $8->size());
+ SwitchInst *S = SwitchInst::Create(tmpVal, tmpBB, $8->size());
$$ = S;
std::vector<std::pair<Constant*,BasicBlock*> >::iterator I = $8->begin(),
CHECK_FOR_ERROR
BasicBlock* tmpBB = getBBVal($6);
CHECK_FOR_ERROR
- SwitchInst *S = new SwitchInst(tmpVal, tmpBB, 0);
+ SwitchInst *S = SwitchInst::Create(tmpVal, tmpBB, 0);
$$ = S;
CHECK_FOR_ERROR
}
GEN_ERROR("Short call syntax cannot be used with varargs");
ParamTypes.push_back(Ty);
}
+
+ if (!FunctionType::isValidReturnType(*$3))
+ GEN_ERROR("Invalid result type for LLVM function");
+
Ty = FunctionType::get($3->get(), ParamTypes, false);
PFTy = PointerType::getUnqual(Ty);
}
BasicBlock *Except = getBBVal($14);
CHECK_FOR_ERROR
- ParamAttrsVector Attrs;
- if ($8 != ParamAttr::None) {
- ParamAttrsWithIndex PAWI; PAWI.index = 0; PAWI.attrs = $8;
- Attrs.push_back(PAWI);
- }
+ SmallVector<ParamAttrsWithIndex, 8> Attrs;
+ if ($8 != ParamAttr::None)
+ Attrs.push_back(ParamAttrsWithIndex::get(0, $8));
// Check the arguments
ValueList Args;
GEN_ERROR("Parameter " + ArgI->Val->getName()+ " is not of type '" +
(*I)->getDescription() + "'");
Args.push_back(ArgI->Val);
- if (ArgI->Attrs != ParamAttr::None) {
- ParamAttrsWithIndex PAWI;
- PAWI.index = index;
- PAWI.attrs = ArgI->Attrs;
- Attrs.push_back(PAWI);
- }
+ if (ArgI->Attrs != ParamAttr::None)
+ Attrs.push_back(ParamAttrsWithIndex::get(index, ArgI->Attrs));
}
if (Ty->isVarArg()) {
if (I == E)
for (; ArgI != ArgE; ++ArgI, ++index) {
Args.push_back(ArgI->Val); // push the remaining varargs
- if (ArgI->Attrs != ParamAttr::None) {
- ParamAttrsWithIndex PAWI;
- PAWI.index = index;
- PAWI.attrs = ArgI->Attrs;
- Attrs.push_back(PAWI);
- }
+ if (ArgI->Attrs != ParamAttr::None)
+ Attrs.push_back(ParamAttrsWithIndex::get(index, ArgI->Attrs));
}
} else if (I != E || ArgI != ArgE)
GEN_ERROR("Invalid number of parameters detected");
}
- const ParamAttrsList *PAL = 0;
+ PAListPtr PAL;
if (!Attrs.empty())
- PAL = ParamAttrsList::get(Attrs);
+ PAL = PAListPtr::get(Attrs.begin(), Attrs.end());
// Create the InvokeInst
- InvokeInst *II = new InvokeInst(V, Normal, Except, Args.begin(), Args.end());
+ InvokeInst *II = InvokeInst::Create(V, Normal, Except,
+ Args.begin(), Args.end());
II->setCallingConv($2);
II->setParamAttrs(PAL);
$$ = II;
GEN_ERROR("fcmp operator returned null");
delete $3;
}
+ | VICMP IPredicates Types ValueRef ',' ValueRef {
+ if (!UpRefs.empty())
+ GEN_ERROR("Invalid upreference in type: " + (*$3)->getDescription());
+ if (!isa<VectorType>((*$3).get()))
+ GEN_ERROR("Scalar types not supported by vicmp instruction");
+ Value* tmpVal1 = getVal(*$3, $4);
+ CHECK_FOR_ERROR
+ Value* tmpVal2 = getVal(*$3, $6);
+ CHECK_FOR_ERROR
+ $$ = CmpInst::create($1, $2, tmpVal1, tmpVal2);
+ if ($$ == 0)
+ GEN_ERROR("icmp operator returned null");
+ delete $3;
+ }
+ | VFCMP FPredicates Types ValueRef ',' ValueRef {
+ if (!UpRefs.empty())
+ GEN_ERROR("Invalid upreference in type: " + (*$3)->getDescription());
+ if (!isa<VectorType>((*$3).get()))
+ GEN_ERROR("Scalar types not supported by vfcmp instruction");
+ Value* tmpVal1 = getVal(*$3, $4);
+ CHECK_FOR_ERROR
+ Value* tmpVal2 = getVal(*$3, $6);
+ CHECK_FOR_ERROR
+ $$ = CmpInst::create($1, $2, tmpVal1, tmpVal2);
+ if ($$ == 0)
+ GEN_ERROR("fcmp operator returned null");
+ delete $3;
+ }
| CastOps ResolvedVal TO Types {
if (!UpRefs.empty())
GEN_ERROR("Invalid upreference in type: " + (*$4)->getDescription());
GEN_ERROR("select condition must be boolean");
if ($4->getType() != $6->getType())
GEN_ERROR("select value types should match");
- $$ = new SelectInst($2, $4, $6);
+ $$ = SelectInst::Create($2, $4, $6);
CHECK_FOR_ERROR
}
| VAARG ResolvedVal ',' Types {
| INSERTELEMENT ResolvedVal ',' ResolvedVal ',' ResolvedVal {
if (!InsertElementInst::isValidOperands($2, $4, $6))
GEN_ERROR("Invalid insertelement operands");
- $$ = new InsertElementInst($2, $4, $6);
+ $$ = InsertElementInst::Create($2, $4, $6);
CHECK_FOR_ERROR
}
| SHUFFLEVECTOR ResolvedVal ',' ResolvedVal ',' ResolvedVal {
const Type *Ty = $2->front().first->getType();
if (!Ty->isFirstClassType())
GEN_ERROR("PHI node operands must be of first class type");
- $$ = new PHINode(Ty);
+ $$ = PHINode::Create(Ty);
((PHINode*)$$)->reserveOperandSpace($2->size());
while ($2->begin() != $2->end()) {
if ($2->front().first->getType() != Ty)
GEN_ERROR("Short call syntax cannot be used with varargs");
ParamTypes.push_back(Ty);
}
+
+ if (!FunctionType::isValidReturnType(*$3))
+ GEN_ERROR("Invalid result type for LLVM function");
+
Ty = FunctionType::get($3->get(), ParamTypes, false);
PFTy = PointerType::getUnqual(Ty);
}
}
// Set up the ParamAttrs for the function
- ParamAttrsVector Attrs;
- if ($8 != ParamAttr::None) {
- ParamAttrsWithIndex PAWI;
- PAWI.index = 0;
- PAWI.attrs = $8;
- Attrs.push_back(PAWI);
- }
+ SmallVector<ParamAttrsWithIndex, 8> Attrs;
+ if ($8 != ParamAttr::None)
+ Attrs.push_back(ParamAttrsWithIndex::get(0, $8));
// Check the arguments
ValueList Args;
if ($6->empty()) { // Has no arguments?
GEN_ERROR("Parameter " + ArgI->Val->getName()+ " is not of type '" +
(*I)->getDescription() + "'");
Args.push_back(ArgI->Val);
- if (ArgI->Attrs != ParamAttr::None) {
- ParamAttrsWithIndex PAWI;
- PAWI.index = index;
- PAWI.attrs = ArgI->Attrs;
- Attrs.push_back(PAWI);
- }
+ if (ArgI->Attrs != ParamAttr::None)
+ Attrs.push_back(ParamAttrsWithIndex::get(index, ArgI->Attrs));
}
if (Ty->isVarArg()) {
if (I == E)
for (; ArgI != ArgE; ++ArgI, ++index) {
Args.push_back(ArgI->Val); // push the remaining varargs
- if (ArgI->Attrs != ParamAttr::None) {
- ParamAttrsWithIndex PAWI;
- PAWI.index = index;
- PAWI.attrs = ArgI->Attrs;
- Attrs.push_back(PAWI);
- }
+ if (ArgI->Attrs != ParamAttr::None)
+ Attrs.push_back(ParamAttrsWithIndex::get(index, ArgI->Attrs));
}
} else if (I != E || ArgI != ArgE)
GEN_ERROR("Invalid number of parameters detected");
}
// Finish off the ParamAttrs and check them
- const ParamAttrsList *PAL = 0;
+ PAListPtr PAL;
if (!Attrs.empty())
- PAL = ParamAttrsList::get(Attrs);
+ PAL = PAListPtr::get(Attrs.begin(), Attrs.end());
// Create the call node
- CallInst *CI = new CallInst(V, Args.begin(), Args.end());
+ CallInst *CI = CallInst::Create(V, Args.begin(), Args.end());
CI->setTailCall($1);
CI->setCallingConv($2);
CI->setParamAttrs(PAL);
$$ = new StoreInst($3, tmpVal, $1, $7);
delete $5;
}
-| GETRESULT Types SymbolicValueRef ',' EUINT64VAL {
+| GETRESULT Types ValueRef ',' EUINT64VAL {
Value *TmpVal = getVal($2->get(), $3);
if (!GetResultInst::isValidOperands(TmpVal, $5))
GEN_ERROR("Invalid getresult operands");
if (!isa<PointerType>($2->get()))
GEN_ERROR("getelementptr insn requires pointer operand");
- if (!GetElementPtrInst::getIndexedType(*$2, $4->begin(), $4->end(), true))
+ if (!GetElementPtrInst::getIndexedType(*$2, $4->begin(), $4->end()))
GEN_ERROR("Invalid getelementptr indices for type '" +
(*$2)->getDescription()+ "'");
Value* tmpVal = getVal(*$2, $3);
CHECK_FOR_ERROR
- $$ = new GetElementPtrInst(tmpVal, $4->begin(), $4->end());
+ $$ = GetElementPtrInst::Create(tmpVal, $4->begin(), $4->end());
delete $2;
delete $4;
};
projects / oota-llvm.git / blobdiff