// Code to handle definitions of all the types
//===----------------------------------------------------------------------===//
-static void InsertValue(Value *V, ValueList &ValueTab = CurFun.Values) {
+/// InsertValue - Insert a value into the value table. If it is named, this
+/// returns -1, otherwise it returns the slot number for the value.
+static int InsertValue(Value *V, ValueList &ValueTab = CurFun.Values) {
// Things that have names or are void typed don't get slot numbers
if (V->hasName() || (V->getType() == Type::VoidTy))
- return;
+ return -1;
// In the case of function values, we have to allow for the forward reference
// of basic blocks, which are included in the numbering. Consequently, we keep
if (ValueTab.size() <= CurFun.NextValNum)
ValueTab.resize(CurFun.NextValNum+1);
ValueTab[CurFun.NextValNum++] = V;
- return;
+ return CurFun.NextValNum-1;
}
// For all other lists, its okay to just tack it on the back of the vector.
ValueTab.push_back(V);
+ return ValueTab.size()-1;
}
static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) {
// This is really a signed reference. Transmogrify.
return ConstantInt::get(Ty, D.ConstPool64, true);
+ case ValID::ConstAPInt: // Is it an unsigned const pool reference?
+ if (!isa<IntegerType>(Ty)) {
+ GenerateError("Integral constant '" + D.getName() +
+ "' is invalid or out of range for type '" +
+ Ty->getDescription() + "'");
+ return 0;
+ }
+
+ {
+ APSInt Tmp = *D.ConstPoolInt;
+ Tmp.extOrTrunc(Ty->getPrimitiveSizeInBits());
+ return ConstantInt::get(Tmp);
+ }
+
case ValID::ConstFPVal: // Is it a floating point const pool reference?
if (!Ty->isFloatingPoint() ||
!ConstantFP::isValueValidForType(Ty, *D.ConstPoolFP)) {
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)) {
if (TriggerError) return 0;
if (!Ty->isFirstClassType() && !isa<OpaqueType>(Ty)) {
- GenerateError("Invalid use of a composite type");
+ GenerateError("Invalid use of a non-first-class type");
return 0;
}
}
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;
}
} if (ID.Type == ValID::LocalName) {
std::string Name = ID.getName();
Value *N = CurFun.CurrentFunction->getValueSymbolTable().lookup(Name);
- if (N)
+ if (N) {
if (N->getType()->getTypeID() == Type::LabelTyID)
BB = cast<BasicBlock>(N);
else
GenerateError("Reference to label '" + Name + "' is actually of type '"+
N->getType()->getDescription() + "'");
+ }
} else if (ID.Type == ValID::LocalID) {
if (ID.Num < CurFun.NextValNum && ID.Num < CurFun.Values.size()) {
if (CurFun.Values[ID.Num]->getType()->getTypeID() == Type::LabelTyID)
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;
GenerateError("Cannot declare global vars of function type");
return 0;
}
+ if (Ty == Type::LabelTy) {
+ GenerateError("Cannot declare global vars of label type");
+ return 0;
+ }
const PointerType *PTy = PointerType::get(Ty, AddressSpace);
llvm::PATypeHolder *TypeVal;
llvm::Value *ValueVal;
std::vector<llvm::Value*> *ValueList;
+ std::vector<unsigned> *ConstantList;
llvm::ArgListType *ArgList;
llvm::TypeWithAttrs TypeWithAttrs;
llvm::TypeWithAttrsList *TypeWithAttrsList;
llvm::GlobalValue::LinkageTypes Linkage;
llvm::GlobalValue::VisibilityTypes Visibility;
- llvm::ParameterAttributes ParamAttrs;
+ llvm::Attributes ParamAttrs;
llvm::APInt *APIntVal;
int64_t SInt64Val;
uint64_t UInt64Val;
%type <PHIList> PHIList
%type <ParamList> ParamList // For call param lists & GEP indices
%type <ValueList> IndexList // For GEP indices
+%type <ConstantList> ConstantIndexList // For insertvalue/extractvalue indices
%type <TypeList> TypeListI
%type <TypeWithAttrsList> ArgTypeList ArgTypeListI
%type <TypeWithAttrs> ArgType
// ValueRef - Unresolved reference to a definition or BB
%type <ValIDVal> ValueRef ConstValueRef SymbolicValueRef
%type <ValueVal> ResolvedVal // <type> <valref> pair
+%type <ValueList> ReturnedVal
// Tokens and types for handling constant integer values
//
// ESINT64VAL - A negative number within long long range
%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 X86_SSECALLCC_TOK
%token DATALAYOUT
-%type <UIntVal> OptCallingConv
+%type <UIntVal> OptCallingConv LocalNumber
%type <ParamAttrs> OptParamAttrs ParamAttr
%type <ParamAttrs> OptFuncAttrs FuncAttr
+%type <ParamAttrs> OptFuncNotes FuncNote
+%type <ParamAttrs> FuncNoteList
// Basic Block Terminating Operators
%token <TermOpVal> RET BR SWITCH INVOKE UNWIND UNREACHABLE
%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
%token <OtherOpVal> PHI_TOK SELECT VAARG
%token <OtherOpVal> EXTRACTELEMENT INSERTELEMENT SHUFFLEVECTOR
%token <OtherOpVal> GETRESULT
+%token <OtherOpVal> EXTRACTVALUE INSERTVALUE
// Function Attributes
%token SIGNEXT ZEROEXT NORETURN INREG SRET NOUNWIND NOALIAS BYVAL NEST
%token READNONE READONLY GC
+// Function Notes
+%token FNNOTE INLINE ALWAYS NEVER OPTIMIZEFORSIZE
+
// Visibility Styles
%token DEFAULT HIDDEN PROTECTED
CHECK_FOR_ERROR
};
+LocalNumber : LOCALVAL_ID '=' {
+ $$ = $1;
+ CHECK_FOR_ERROR
+};
+
+
GlobalName : GLOBALVAR | ATSTRINGCONSTANT ;
OptGlobalAssign : GlobalAssign
| LINKONCE { $$ = GlobalValue::LinkOnceLinkage; }
| APPENDING { $$ = GlobalValue::AppendingLinkage; }
| DLLEXPORT { $$ = GlobalValue::DLLExportLinkage; }
+ | COMMON { $$ = GlobalValue::CommonLinkage; }
;
GVExternalLinkage
COLDCC_TOK { $$ = CallingConv::Cold; } |
X86_STDCALLCC_TOK { $$ = CallingConv::X86_StdCall; } |
X86_FASTCALLCC_TOK { $$ = CallingConv::X86_FastCall; } |
+ X86_SSECALLCC_TOK { $$ = CallingConv::X86_SSECall; } |
CC_TOK EUINT64VAL {
if ((unsigned)$2 != $2)
GEN_ERROR("Calling conv too large");
| NOALIAS { $$ = ParamAttr::NoAlias; }
| BYVAL { $$ = ParamAttr::ByVal; }
| NEST { $$ = ParamAttr::Nest; }
+ | ALIGN EUINT64VAL { $$ =
+ ParamAttr::constructAlignmentFromInt($2); }
;
OptParamAttrs : /* empty */ { $$ = ParamAttr::None; }
FuncAttr : NORETURN { $$ = ParamAttr::NoReturn; }
| NOUNWIND { $$ = ParamAttr::NoUnwind; }
+ | INREG { $$ = ParamAttr::InReg; }
| ZEROEXT { $$ = ParamAttr::ZExt; }
| SIGNEXT { $$ = ParamAttr::SExt; }
| READNONE { $$ = ParamAttr::ReadNone; }
}
;
+FuncNoteList : FuncNote { $$ = $1; }
+ | FuncNoteList ',' FuncNote {
+ unsigned tmp = $1 | $3;
+ if ($3 == FN_NOTE_NoInline
+ && ($1 & FN_NOTE_AlwaysInline))
+ GEN_ERROR("Function Notes may include only one inline notes!")
+ if ($3 == FN_NOTE_AlwaysInline
+ && ($1 & FN_NOTE_NoInline))
+ GEN_ERROR("Function Notes may include only one inline notes!")
+ $$ = tmp;
+ CHECK_FOR_ERROR
+ }
+ ;
+
+FuncNote : INLINE '=' NEVER { $$ = FN_NOTE_NoInline; }
+ | INLINE '=' ALWAYS { $$ = FN_NOTE_AlwaysInline; }
+ | OPTIMIZEFORSIZE { $$ = FN_NOTE_OptimizeForSize; }
+ ;
+
+OptFuncNotes : /* empty */ { $$ = FN_NOTE_None; }
+ | FNNOTE '(' FuncNoteList ')' {
+ $$ = $3;
+ }
+ ;
+
OptGC : /* empty */ { $$ = 0; }
| GC STRINGCONSTANT {
$$ = $2;
| 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 ) {
}
| '[' EUINT64VAL 'x' Types ']' { // Sized array type?
- $$ = new PATypeHolder(HandleUpRefs(ArrayType::get(*$4, (unsigned)$2)));
+ $$ = new PATypeHolder(HandleUpRefs(ArrayType::get(*$4, $2)));
delete $4;
CHECK_FOR_ERROR
}
: Types {
if (!UpRefs.empty())
GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription());
- if (!(*$1)->isFirstClassType())
+ if (!(*$1)->isFirstClassType() && !isa<StructType>($1->get()))
GEN_ERROR("LLVM functions cannot return aggregate types");
$$ = $1;
}
GEN_ERROR("Cannot make array constant with type: '" +
(*$1)->getDescription() + "'");
const Type *ETy = ATy->getElementType();
- int NumElements = ATy->getNumElements();
+ uint64_t NumElements = ATy->getNumElements();
// Verify that we have the correct size...
- if (NumElements != -1 && NumElements != (int)$3->size())
+ if (NumElements != uint64_t(-1) && NumElements != $3->size())
GEN_ERROR("Type mismatch: constant sized array initialized with " +
utostr($3->size()) + " arguments, but has size of " +
- itostr(NumElements) + "");
+ utostr(NumElements) + "");
// Verify all elements are correct type!
for (unsigned i = 0; i < $3->size(); i++) {
GEN_ERROR("Cannot make array constant with type: '" +
(*$1)->getDescription() + "'");
- int NumElements = ATy->getNumElements();
- if (NumElements != -1 && NumElements != 0)
+ uint64_t NumElements = ATy->getNumElements();
+ if (NumElements != uint64_t(-1) && NumElements != 0)
GEN_ERROR("Type mismatch: constant sized array initialized with 0"
- " arguments, but has size of " + itostr(NumElements) +"");
+ " arguments, but has size of " + utostr(NumElements) +"");
$$ = ConstantArray::get(ATy, std::vector<Constant*>());
delete $1;
CHECK_FOR_ERROR
GEN_ERROR("Cannot make array constant with type: '" +
(*$1)->getDescription() + "'");
- int NumElements = ATy->getNumElements();
+ uint64_t NumElements = ATy->getNumElements();
const Type *ETy = ATy->getElementType();
- if (NumElements != -1 && NumElements != int($3->length()))
+ if (NumElements != uint64_t(-1) && NumElements != $3->length())
GEN_ERROR("Can't build string constant of size " +
- itostr((int)($3->length())) +
- " when array has size " + itostr(NumElements) + "");
+ utostr($3->length()) +
+ " when array has size " + utostr(NumElements) + "");
std::vector<Constant*> Vals;
if (ETy == Type::Int8Ty) {
- for (unsigned i = 0; i < $3->length(); ++i)
+ for (uint64_t i = 0; i < $3->length(); ++i)
Vals.push_back(ConstantInt::get(ETy, (*$3)[i]));
} else {
delete $3;
GEN_ERROR("Cannot make packed constant with type: '" +
(*$1)->getDescription() + "'");
const Type *ETy = PTy->getElementType();
- int NumElements = PTy->getNumElements();
+ unsigned NumElements = PTy->getNumElements();
// Verify that we have the correct size...
- if (NumElements != -1 && NumElements != (int)$3->size())
+ if (NumElements != unsigned(-1) && NumElements != (unsigned)$3->size())
GEN_ERROR("Type mismatch: constant sized packed initialized with " +
utostr($3->size()) + " arguments, but has size of " +
- itostr(NumElements) + "");
+ utostr(NumElements) + "");
// Verify all elements are correct type!
for (unsigned i = 0; i < $3->size(); 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,
CHECK_FOR_ERROR
}
| INTTYPE TRUETOK { // Boolean constants
- assert(cast<IntegerType>($1)->getBitWidth() == 1 && "Not Bool?");
+ if (cast<IntegerType>($1)->getBitWidth() != 1)
+ GEN_ERROR("Constant true must have type i1");
$$ = ConstantInt::getTrue();
CHECK_FOR_ERROR
}
| INTTYPE FALSETOK { // Boolean constants
- assert(cast<IntegerType>($1)->getBitWidth() == 1 && "Not Bool?");
+ if (cast<IntegerType>($1)->getBitWidth() != 1)
+ GEN_ERROR("Constant false must have type i1");
$$ = ConstantInt::getFalse();
CHECK_FOR_ERROR
}
// 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");
if ($3->getType() != $5->getType())
GEN_ERROR("Logical operator types must match");
if (!$3->getType()->isInteger()) {
- if (Instruction::isShift($1) || !isa<VectorType>($3->getType()) ||
+ if (!isa<VectorType>($3->getType()) ||
!cast<VectorType>($3->getType())->getElementType()->isInteger())
GEN_ERROR("Logical operator requires integral operands");
}
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");
GEN_ERROR("Invalid shufflevector operands");
$$ = ConstantExpr::getShuffleVector($3, $5, $7);
CHECK_FOR_ERROR
+ }
+ | EXTRACTVALUE '(' ConstVal ConstantIndexList ')' {
+ if (!isa<StructType>($3->getType()) && !isa<ArrayType>($3->getType()))
+ GEN_ERROR("ExtractValue requires an aggregate operand");
+
+ $$ = ConstantExpr::getExtractValue($3, &(*$4)[0], $4->size());
+ delete $4;
+ CHECK_FOR_ERROR
+ }
+ | INSERTVALUE '(' ConstVal ',' ConstVal ConstantIndexList ')' {
+ if (!isa<StructType>($3->getType()) && !isa<ArrayType>($3->getType()))
+ GEN_ERROR("InsertValue requires an aggregate operand");
+
+ $$ = ConstantExpr::getInsertValue($3, $5, &(*$6)[0], $6->size());
+ delete $6;
+ CHECK_FOR_ERROR
};
ArgListH : ArgListH ',' Types OptParamAttrs OptLocalName {
if (!UpRefs.empty())
GEN_ERROR("Invalid upreference in type: " + (*$3)->getDescription());
- if (*$3 == Type::VoidTy)
- GEN_ERROR("void typed arguments are invalid");
+ if (!(*$3)->isFirstClassType())
+ GEN_ERROR("Argument types must be first-class");
ArgListEntry E; E.Attrs = $4; E.Ty = $3; E.Name = $5;
$$ = $1;
$1->push_back(E);
| Types OptParamAttrs OptLocalName {
if (!UpRefs.empty())
GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription());
- if (*$1 == Type::VoidTy)
- GEN_ERROR("void typed arguments are invalid");
+ if (!(*$1)->isFirstClassType())
+ GEN_ERROR("Argument types must be first-class");
ArgListEntry E; E.Attrs = $2; E.Ty = $1; E.Name = $3;
$$ = new ArgListType;
$$->push_back(E);
};
FunctionHeaderH : OptCallingConv ResultTypes GlobalName '(' ArgList ')'
- OptFuncAttrs OptSection OptAlign OptGC {
+ OptFuncAttrs OptSection OptAlign OptGC OptFuncNotes {
std::string FunctionName(*$3);
delete $3; // Free strdup'd memory!
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);
}
delete $8;
}
if ($10) {
- Fn->setCollector($10->c_str());
+ Fn->setGC($10->c_str());
delete $10;
}
+ if ($11) {
+ Fn->setNotes($11);
+ }
// Add all of the arguments we parsed to the function...
if ($5) { // Is null if empty...
$$ = ValID::create($1);
CHECK_FOR_ERROR
}
+ | ESAPINTVAL { // arbitrary precision integer constants
+ $$ = ValID::create(*$1, true);
+ delete $1;
+ CHECK_FOR_ERROR
+ }
+ | EUAPINTVAL { // arbitrary precision integer constants
+ $$ = ValID::create(*$1, false);
+ delete $1;
+ CHECK_FOR_ERROR
+ }
| FPVAL { // Perhaps it's an FP constant?
$$ = ValID::create($1);
CHECK_FOR_ERROR
}
| '<' ConstVector '>' { // Nonempty unsized packed vector
const Type *ETy = (*$2)[0]->getType();
- int NumElements = $2->size();
+ unsigned NumElements = $2->size();
+
+ if (!ETy->isInteger() && !ETy->isFloatingPoint())
+ GEN_ERROR("Invalid vector element type: " + ETy->getDescription());
VectorType* pt = VectorType::get(ETy, NumElements);
- PATypeHolder* PTy = new PATypeHolder(
- HandleUpRefs(
- VectorType::get(
- ETy,
- NumElements)
- )
- );
+ PATypeHolder* PTy = new PATypeHolder(HandleUpRefs(pt));
// Verify all elements are correct type!
for (unsigned i = 0; i < $2->size(); i++) {
delete PTy; delete $2;
CHECK_FOR_ERROR
}
+ | '[' ConstVector ']' { // Nonempty unsized arr
+ const Type *ETy = (*$2)[0]->getType();
+ uint64_t NumElements = $2->size();
+
+ if (!ETy->isFirstClassType())
+ GEN_ERROR("Invalid array element type: " + ETy->getDescription());
+
+ ArrayType *ATy = ArrayType::get(ETy, NumElements);
+ PATypeHolder* PTy = new PATypeHolder(HandleUpRefs(ATy));
+
+ // Verify all elements are correct type!
+ for (unsigned i = 0; i < $2->size(); i++) {
+ if (ETy != (*$2)[i]->getType())
+ GEN_ERROR("Element #" + utostr(i) + " is not of type '" +
+ ETy->getDescription() +"' as required!\nIt is of type '"+
+ (*$2)[i]->getType()->getDescription() + "'.");
+ }
+
+ $$ = ValID::create(ConstantArray::get(ATy, *$2));
+ delete PTy; delete $2;
+ CHECK_FOR_ERROR
+ }
+ | '[' ']' {
+ // Use undef instead of an array because it's inconvenient to determine
+ // the element type at this point, there being no elements to examine.
+ $$ = ValID::createUndef();
+ CHECK_FOR_ERROR
+ }
+ | 'c' STRINGCONSTANT {
+ uint64_t NumElements = $2->length();
+ const Type *ETy = Type::Int8Ty;
+
+ ArrayType *ATy = ArrayType::get(ETy, NumElements);
+
+ std::vector<Constant*> Vals;
+ for (unsigned i = 0; i < $2->length(); ++i)
+ Vals.push_back(ConstantInt::get(ETy, (*$2)[i]));
+ delete $2;
+ $$ = ValID::create(ConstantArray::get(ATy, Vals));
+ CHECK_FOR_ERROR
+ }
+ | '{' ConstVector '}' {
+ std::vector<const Type*> Elements($2->size());
+ for (unsigned i = 0, e = $2->size(); i != e; ++i)
+ Elements[i] = (*$2)[i]->getType();
+
+ const StructType *STy = StructType::get(Elements);
+ PATypeHolder* PTy = new PATypeHolder(HandleUpRefs(STy));
+
+ $$ = ValID::create(ConstantStruct::get(STy, *$2));
+ delete PTy; delete $2;
+ CHECK_FOR_ERROR
+ }
+ | '{' '}' {
+ const StructType *STy = StructType::get(std::vector<const Type*>());
+ $$ = ValID::create(ConstantStruct::get(STy, std::vector<Constant*>()));
+ CHECK_FOR_ERROR
+ }
+ | '<' '{' ConstVector '}' '>' {
+ std::vector<const Type*> Elements($3->size());
+ for (unsigned i = 0, e = $3->size(); i != e; ++i)
+ Elements[i] = (*$3)[i]->getType();
+
+ const StructType *STy = StructType::get(Elements, /*isPacked=*/true);
+ PATypeHolder* PTy = new PATypeHolder(HandleUpRefs(STy));
+
+ $$ = ValID::create(ConstantStruct::get(STy, *$3));
+ delete PTy; delete $3;
+ CHECK_FOR_ERROR
+ }
+ | '<' '{' '}' '>' {
+ const StructType *STy = StructType::get(std::vector<const Type*>(),
+ /*isPacked=*/true);
+ $$ = ValID::create(ConstantStruct::get(STy, std::vector<Constant*>()));
+ CHECK_FOR_ERROR
+ }
| ConstExpr {
$$ = ValID::create($1);
CHECK_FOR_ERROR
}
;
+ReturnedVal : ResolvedVal {
+ $$ = new std::vector<Value *>();
+ $$->push_back($1);
+ CHECK_FOR_ERROR
+ }
+ | ReturnedVal ',' ResolvedVal {
+ ($$=$1)->push_back($3);
+ CHECK_FOR_ERROR
+ };
+
BasicBlockList : BasicBlockList BasicBlock {
$$ = $1;
CHECK_FOR_ERROR
// Basic blocks are terminated by branching instructions:
// br, br/cc, switch, ret
//
-BasicBlock : InstructionList OptLocalAssign BBTerminatorInst {
+BasicBlock : InstructionList OptLocalAssign BBTerminatorInst {
setValueName($3, $2);
CHECK_FOR_ERROR
InsertValue($3);
CHECK_FOR_ERROR
};
+BasicBlock : InstructionList LocalNumber BBTerminatorInst {
+ CHECK_FOR_ERROR
+ int ValNum = InsertValue($3);
+ if (ValNum != (int)$2)
+ GEN_ERROR("Result value number %" + utostr($2) +
+ " is incorrect, expected %" + utostr((unsigned)ValNum));
+
+ $1->getInstList().push_back($3);
+ $$ = $1;
+ CHECK_FOR_ERROR
+};
+
+
InstructionList : InstructionList Inst {
if (CastInst *CI1 = dyn_cast<CastInst>($2))
if (CastInst *CI2 = dyn_cast<CastInst>(CI1->getOperand(0)))
};
-BBTerminatorInst : RET ResolvedVal { // Return with a result...
- $$ = new ReturnInst($2);
+BBTerminatorInst :
+ RET ReturnedVal { // Return with a result...
+ ValueList &VL = *$2;
+ assert(!VL.empty() && "Invalid ret operands!");
+ const Type *ReturnType = CurFun.CurrentFunction->getReturnType();
+ if (VL.size() > 1 ||
+ (isa<StructType>(ReturnType) &&
+ (VL.empty() || VL[0]->getType() != ReturnType))) {
+ Value *RV = UndefValue::get(ReturnType);
+ for (unsigned i = 0, e = VL.size(); i != e; ++i) {
+ Instruction *I = InsertValueInst::Create(RV, VL[i], i, "mrv");
+ ($<BasicBlockVal>-1)->getInstList().push_back(I);
+ RV = I;
+ }
+ $$ = ReturnInst::Create(RV);
+ } else {
+ $$ = ReturnInst::Create(VL[0]);
+ }
+ 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?");
+ if (cast<IntegerType>($2)->getBitWidth() != 1)
+ GEN_ERROR("Branch condition must have type i1");
BasicBlock* tmpBBA = getBBVal($6);
CHECK_FOR_ERROR
BasicBlock* tmpBBB = getBBVal($9);
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;
CHECK_FOR_ERROR
};
+Inst : LocalNumber InstVal {
+ CHECK_FOR_ERROR
+ int ValNum = InsertValue($2);
+
+ if (ValNum != (int)$1)
+ GEN_ERROR("Result value number %" + utostr($1) +
+ " is incorrect, expected %" + utostr((unsigned)ValNum));
+
+ $$ = $2;
+ CHECK_FOR_ERROR
+ };
+
PHIList : Types '[' ValueRef ',' ValueRef ']' { // Used for PHI nodes
if (!UpRefs.empty())
}
;
+ConstantIndexList // Used for insertvalue and extractvalue instructions
+ : ',' EUINT64VAL {
+ $$ = new std::vector<unsigned>();
+ if ((unsigned)$2 != $2)
+ GEN_ERROR("Index " + utostr($2) + " is not valid for insertvalue or extractvalue.");
+ $$->push_back($2);
+ }
+ | ConstantIndexList ',' EUINT64VAL {
+ $$ = $1;
+ if ((unsigned)$3 != $3)
+ GEN_ERROR("Index " + utostr($3) + " is not valid for insertvalue or extractvalue.");
+ $$->push_back($3);
+ CHECK_FOR_ERROR
+ }
+ ;
+
OptTailCall : TAIL CALL {
$$ = true;
CHECK_FOR_ERROR
CHECK_FOR_ERROR
Value* val2 = getVal(*$2, $5);
CHECK_FOR_ERROR
- $$ = BinaryOperator::create($1, val1, val2);
+ $$ = BinaryOperator::Create($1, val1, val2);
if ($$ == 0)
GEN_ERROR("binary operator returned null");
delete $2;
if (!UpRefs.empty())
GEN_ERROR("Invalid upreference in type: " + (*$2)->getDescription());
if (!(*$2)->isInteger()) {
- if (Instruction::isShift($1) || !isa<VectorType>($2->get()) ||
+ if (!isa<VectorType>($2->get()) ||
!cast<VectorType>($2->get())->getElementType()->isInteger())
GEN_ERROR("Logical operator requires integral operands");
}
CHECK_FOR_ERROR
Value* tmpVal2 = getVal(*$2, $5);
CHECK_FOR_ERROR
- $$ = BinaryOperator::create($1, tmpVal1, tmpVal2);
+ $$ = BinaryOperator::Create($1, tmpVal1, tmpVal2);
if ($$ == 0)
GEN_ERROR("binary operator returned null");
delete $2;
| ICMP IPredicates Types ValueRef ',' ValueRef {
if (!UpRefs.empty())
GEN_ERROR("Invalid upreference in type: " + (*$3)->getDescription());
- if (isa<VectorType>((*$3).get()))
- GEN_ERROR("Vector types not supported by icmp instruction");
Value* tmpVal1 = getVal(*$3, $4);
CHECK_FOR_ERROR
Value* tmpVal2 = getVal(*$3, $6);
CHECK_FOR_ERROR
- $$ = CmpInst::create($1, $2, tmpVal1, tmpVal2);
+ $$ = CmpInst::Create($1, $2, tmpVal1, tmpVal2);
if ($$ == 0)
GEN_ERROR("icmp operator returned null");
delete $3;
| FCMP FPredicates Types ValueRef ',' ValueRef {
if (!UpRefs.empty())
GEN_ERROR("Invalid upreference in type: " + (*$3)->getDescription());
- if (isa<VectorType>((*$3).get()))
- GEN_ERROR("Vector types not supported by fcmp instruction");
Value* tmpVal1 = getVal(*$3, $4);
CHECK_FOR_ERROR
Value* tmpVal2 = getVal(*$3, $6);
CHECK_FOR_ERROR
- $$ = CmpInst::create($1, $2, tmpVal1, tmpVal2);
+ $$ = CmpInst::Create($1, $2, tmpVal1, tmpVal2);
if ($$ == 0)
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("vicmp 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("vfcmp operator returned null");
+ delete $3;
+ }
| CastOps ResolvedVal TO Types {
if (!UpRefs.empty())
GEN_ERROR("Invalid upreference in type: " + (*$4)->getDescription());
GEN_ERROR("invalid cast opcode for cast from '" +
Val->getType()->getDescription() + "' to '" +
DestTy->getDescription() + "'");
- $$ = CastInst::create($1, Val, DestTy);
+ $$ = CastInst::Create($1, Val, DestTy);
delete $4;
}
| SELECT ResolvedVal ',' ResolvedVal ',' ResolvedVal {
- if ($2->getType() != Type::Int1Ty)
- GEN_ERROR("select condition must be boolean");
+ if (isa<VectorType>($2->getType())) {
+ // vector select
+ if (!isa<VectorType>($4->getType())
+ || !isa<VectorType>($6->getType()) )
+ GEN_ERROR("vector select value types must be vector types");
+ const VectorType* cond_type = cast<VectorType>($2->getType());
+ const VectorType* select_type = cast<VectorType>($4->getType());
+ if (cond_type->getElementType() != Type::Int1Ty)
+ GEN_ERROR("vector select condition element type must be boolean");
+ if (cond_type->getNumElements() != select_type->getNumElements())
+ GEN_ERROR("vector select number of elements must be the same");
+ } else {
+ if ($2->getType() != Type::Int1Ty)
+ GEN_ERROR("select condition must be boolean");
+ }
if ($4->getType() != $6->getType())
- GEN_ERROR("select value types should match");
- $$ = new SelectInst($2, $4, $6);
+ GEN_ERROR("select value types must match");
+ $$ = 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);
| MALLOC Types ',' INTTYPE ValueRef OptCAlign {
if (!UpRefs.empty())
GEN_ERROR("Invalid upreference in type: " + (*$2)->getDescription());
+ if ($4 != Type::Int32Ty)
+ GEN_ERROR("Malloc array size is not a 32-bit integer!");
Value* tmpVal = getVal($4, $5);
CHECK_FOR_ERROR
$$ = new MallocInst(*$2, tmpVal, $6);
| ALLOCA Types ',' INTTYPE ValueRef OptCAlign {
if (!UpRefs.empty())
GEN_ERROR("Invalid upreference in type: " + (*$2)->getDescription());
+ if ($4 != Type::Int32Ty)
+ GEN_ERROR("Alloca array size is not a 32-bit integer!");
Value* tmpVal = getVal($4, $5);
CHECK_FOR_ERROR
$$ = new AllocaInst(*$2, tmpVal, $6);
$$ = new StoreInst($3, tmpVal, $1, $7);
delete $5;
}
-| GETRESULT Types LocalName ',' ConstVal {
- ValID TmpVID = ValID::createLocalName(*$3);
- Value *TmpVal = getVal($2->get(), TmpVID);
- if (!GetResultInst::isValidOperands(TmpVal, $5))
- GEN_ERROR("Invalid getresult operands");
- $$ = new GetResultInst(TmpVal, $5);
+ | GETRESULT Types ValueRef ',' EUINT64VAL {
+ if (!UpRefs.empty())
+ GEN_ERROR("Invalid upreference in type: " + (*$2)->getDescription());
+ if (!isa<StructType>($2->get()) && !isa<ArrayType>($2->get()))
+ GEN_ERROR("getresult insn requires an aggregate operand");
+ if (!ExtractValueInst::getIndexedType(*$2, $5))
+ GEN_ERROR("Invalid getresult index for type '" +
+ (*$2)->getDescription()+ "'");
+
+ Value *tmpVal = getVal(*$2, $3);
CHECK_FOR_ERROR
+ $$ = ExtractValueInst::Create(tmpVal, $5);
+ delete $2;
}
| GETELEMENTPTR Types ValueRef IndexList {
if (!UpRefs.empty())
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;
+ }
+ | EXTRACTVALUE Types ValueRef ConstantIndexList {
+ if (!UpRefs.empty())
+ GEN_ERROR("Invalid upreference in type: " + (*$2)->getDescription());
+ if (!isa<StructType>($2->get()) && !isa<ArrayType>($2->get()))
+ GEN_ERROR("extractvalue insn requires an aggregate operand");
+
+ if (!ExtractValueInst::getIndexedType(*$2, $4->begin(), $4->end()))
+ GEN_ERROR("Invalid extractvalue indices for type '" +
+ (*$2)->getDescription()+ "'");
+ Value* tmpVal = getVal(*$2, $3);
+ CHECK_FOR_ERROR
+ $$ = ExtractValueInst::Create(tmpVal, $4->begin(), $4->end());
delete $2;
delete $4;
+ }
+ | INSERTVALUE Types ValueRef ',' Types ValueRef ConstantIndexList {
+ if (!UpRefs.empty())
+ GEN_ERROR("Invalid upreference in type: " + (*$2)->getDescription());
+ if (!isa<StructType>($2->get()) && !isa<ArrayType>($2->get()))
+ GEN_ERROR("extractvalue insn requires an aggregate operand");
+
+ if (ExtractValueInst::getIndexedType(*$2, $7->begin(), $7->end()) != $5->get())
+ GEN_ERROR("Invalid insertvalue indices for type '" +
+ (*$2)->getDescription()+ "'");
+ Value* aggVal = getVal(*$2, $3);
+ Value* tmpVal = getVal(*$5, $6);
+ CHECK_FOR_ERROR
+ $$ = InsertValueInst::Create(aggVal, tmpVal, $7->begin(), $7->end());
+ delete $2;
+ delete $5;
+ delete $7;
};
projects / oota-llvm.git / blobdiff