From 5694b6e90eaf94fa7a21f101a8e4424d813a85ce Mon Sep 17 00:00:00 2001 From: Reid Spencer Date: Mon, 9 Apr 2007 06:17:21 +0000 Subject: For PR1146: Adapt handling of parameter attributes to use the new ParamAttrsList class. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35814 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/AsmParser/ParserInternals.h | 7 +- lib/AsmParser/llvmAsmParser.y | 121 +++++++++++++++++--------- lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp | 30 ++++--- lib/Target/CBackend/CBackend.cpp | 21 +++-- lib/Target/MSIL/MSILWriter.cpp | 6 +- 5 files changed, 116 insertions(+), 69 deletions(-) (limited to 'lib') diff --git a/lib/AsmParser/ParserInternals.h b/lib/AsmParser/ParserInternals.h index 6396d94..2b50cf6 100644 --- a/lib/AsmParser/ParserInternals.h +++ b/lib/AsmParser/ParserInternals.h @@ -17,6 +17,7 @@ #include "llvm/Constants.h" #include "llvm/DerivedTypes.h" +#include "llvm/ParameterAttributes.h" #include "llvm/Function.h" #include "llvm/Instructions.h" #include "llvm/Assembly/Parser.h" @@ -231,13 +232,13 @@ struct ValID { struct TypeWithAttrs { llvm::PATypeHolder *Ty; - FunctionType::ParameterAttributes Attrs; + uint16_t Attrs; }; typedef std::vector TypeWithAttrsList; struct ArgListEntry { - FunctionType::ParameterAttributes Attrs; + uint16_t Attrs; llvm::PATypeHolder *Ty; char *Name; }; @@ -246,7 +247,7 @@ typedef std::vector ArgListType; struct ValueRefListEntry { Value *Val; - FunctionType::ParameterAttributes Attrs; + uint16_t Attrs; }; typedef std::vector ValueRefList; diff --git a/lib/AsmParser/llvmAsmParser.y b/lib/AsmParser/llvmAsmParser.y index 030e057..92d06a7 100644 --- a/lib/AsmParser/llvmAsmParser.y +++ b/lib/AsmParser/llvmAsmParser.y @@ -200,8 +200,6 @@ static struct PerModuleInfo { } return false; } - - } CurModule; static struct PerFunctionInfo { @@ -962,7 +960,7 @@ Module *llvm::RunVMAsmParser(const char * AsmString, Module * M) { llvm::GlobalValue::LinkageTypes Linkage; llvm::GlobalValue::VisibilityTypes Visibility; - llvm::FunctionType::ParameterAttributes ParamAttrs; + uint16_t ParamAttrs; llvm::APInt *APIntVal; int64_t SInt64Val; uint64_t UInt64Val; @@ -1191,26 +1189,26 @@ OptCallingConv : /*empty*/ { $$ = CallingConv::C; } | CHECK_FOR_ERROR }; -ParamAttr : ZEXT { $$ = FunctionType::ZExtAttribute; } - | SEXT { $$ = FunctionType::SExtAttribute; } - | INREG { $$ = FunctionType::InRegAttribute; } - | SRET { $$ = FunctionType::StructRetAttribute; } +ParamAttr : ZEXT { $$ = ZExtAttribute; } + | SEXT { $$ = SExtAttribute; } + | INREG { $$ = InRegAttribute; } + | SRET { $$ = StructRetAttribute; } ; -OptParamAttrs : /* empty */ { $$ = FunctionType::NoAttributeSet; } +OptParamAttrs : /* empty */ { $$ = NoAttributeSet; } | OptParamAttrs ParamAttr { - $$ = FunctionType::ParameterAttributes($1 | $2); + $$ = $1 | $2; } ; -FuncAttr : NORETURN { $$ = FunctionType::NoReturnAttribute; } - | NOUNWIND { $$ = FunctionType::NoUnwindAttribute; } +FuncAttr : NORETURN { $$ = NoReturnAttribute; } + | NOUNWIND { $$ = NoUnwindAttribute; } | ParamAttr ; -OptFuncAttrs : /* empty */ { $$ = FunctionType::NoAttributeSet; } +OptFuncAttrs : /* empty */ { $$ = NoAttributeSet; } | OptFuncAttrs FuncAttr { - $$ = FunctionType::ParameterAttributes($1 | $2); + $$ = $1 | $2; } ; @@ -1299,18 +1297,25 @@ Types } | Types '(' ArgTypeListI ')' OptFuncAttrs { std::vector Params; - std::vector Attrs; - Attrs.push_back($5); - for (TypeWithAttrsList::iterator I=$3->begin(), E=$3->end(); I != E; ++I) { + ParamAttrsList Attrs; + if ($5 != NoAttributeSet) + Attrs.addAttributes(0, $5); + unsigned index = 1; + TypeWithAttrsList::iterator I = $3->begin(), E = $3->end(); + for (; I != E; ++I, ++index) { const Type *Ty = I->Ty->get(); Params.push_back(Ty); if (Ty != Type::VoidTy) - Attrs.push_back(I->Attrs); + if (I->Attrs != NoAttributeSet) + Attrs.addAttributes(index, I->Attrs); } bool isVarArg = Params.size() && Params.back() == Type::VoidTy; if (isVarArg) Params.pop_back(); - FunctionType *FT = FunctionType::get(*$1, Params, isVarArg, Attrs); + ParamAttrsList *ActualAttrs = 0; + if (!Attrs.empty()) + ActualAttrs = new ParamAttrsList(Attrs); + FunctionType *FT = FunctionType::get(*$1, Params, isVarArg, ActualAttrs); delete $3; // Delete the argument list delete $1; // Delete the return type handle $$ = new PATypeHolder(HandleUpRefs(FT)); @@ -1318,18 +1323,26 @@ Types } | VOID '(' ArgTypeListI ')' OptFuncAttrs { std::vector Params; - std::vector Attrs; - Attrs.push_back($5); - for (TypeWithAttrsList::iterator I=$3->begin(), E=$3->end(); I != E; ++I) { + ParamAttrsList Attrs; + if ($5 != NoAttributeSet) + Attrs.addAttributes(0, $5); + TypeWithAttrsList::iterator I = $3->begin(), E = $3->end(); + unsigned index = 1; + for ( ; I != E; ++I, ++index) { const Type* Ty = I->Ty->get(); Params.push_back(Ty); if (Ty != Type::VoidTy) - Attrs.push_back(I->Attrs); + if (I->Attrs != NoAttributeSet) + Attrs.addAttributes(index, I->Attrs); } bool isVarArg = Params.size() && Params.back() == Type::VoidTy; if (isVarArg) Params.pop_back(); - FunctionType *FT = FunctionType::get($1, Params, isVarArg, Attrs); + ParamAttrsList *ActualAttrs = 0; + if (!Attrs.empty()) + ActualAttrs = new ParamAttrsList(Attrs); + + FunctionType *FT = FunctionType::get($1, Params, isVarArg, ActualAttrs); delete $3; // Delete the argument list $$ = new PATypeHolder(HandleUpRefs(FT)); CHECK_FOR_ERROR @@ -1417,14 +1430,14 @@ ArgTypeListI : ArgTypeList | ArgTypeList ',' DOTDOTDOT { $$=$1; - TypeWithAttrs TWA; TWA.Attrs = FunctionType::NoAttributeSet; + TypeWithAttrs TWA; TWA.Attrs = NoAttributeSet; TWA.Ty = new PATypeHolder(Type::VoidTy); $$->push_back(TWA); CHECK_FOR_ERROR } | DOTDOTDOT { $$ = new TypeWithAttrsList; - TypeWithAttrs TWA; TWA.Attrs = FunctionType::NoAttributeSet; + TypeWithAttrs TWA; TWA.Attrs = NoAttributeSet; TWA.Ty = new PATypeHolder(Type::VoidTy); $$->push_back(TWA); CHECK_FOR_ERROR @@ -2087,7 +2100,7 @@ ArgList : ArgListH { struct ArgListEntry E; E.Ty = new PATypeHolder(Type::VoidTy); E.Name = 0; - E.Attrs = FunctionType::NoAttributeSet; + E.Attrs = NoAttributeSet; $$->push_back(E); CHECK_FOR_ERROR } @@ -2096,7 +2109,7 @@ ArgList : ArgListH { struct ArgListEntry E; E.Ty = new PATypeHolder(Type::VoidTy); E.Name = 0; - E.Attrs = FunctionType::NoAttributeSet; + E.Attrs = NoAttributeSet; $$->push_back(E); CHECK_FOR_ERROR } @@ -2117,24 +2130,31 @@ FunctionHeaderH : OptCallingConv ResultTypes GlobalName '(' ArgList ')' GEN_ERROR("Reference to abstract result: "+ $2->get()->getDescription()); std::vector ParamTypeList; - std::vector ParamAttrs; - ParamAttrs.push_back($7); + ParamAttrsList ParamAttrs; + if ($7 != NoAttributeSet) + ParamAttrs.addAttributes(0, $7); if ($5) { // If there are arguments... - for (ArgListType::iterator I = $5->begin(); I != $5->end(); ++I) { + unsigned index = 1; + for (ArgListType::iterator I = $5->begin(); I != $5->end(); ++I, ++index) { const Type* Ty = I->Ty->get(); if (!CurFun.isDeclare && CurModule.TypeIsUnresolved(I->Ty)) GEN_ERROR("Reference to abstract argument: " + Ty->getDescription()); ParamTypeList.push_back(Ty); if (Ty != Type::VoidTy) - ParamAttrs.push_back(I->Attrs); + if (I->Attrs != NoAttributeSet) + ParamAttrs.addAttributes(index, I->Attrs); } } bool isVarArg = ParamTypeList.size() && ParamTypeList.back() == Type::VoidTy; if (isVarArg) ParamTypeList.pop_back(); - FunctionType *FT = FunctionType::get(*$2, ParamTypeList, isVarArg, - ParamAttrs); + ParamAttrsList *ActualAttrs = 0; + if (!ParamAttrs.empty()) + ActualAttrs = new ParamAttrsList(ParamAttrs); + + FunctionType *FT = FunctionType::get(*$2, ParamTypeList, isVarArg, + ActualAttrs); const PointerType *PFT = PointerType::get(FT); delete $2; @@ -2465,17 +2485,24 @@ BBTerminatorInst : RET ResolvedVal { // Return with a result... !(Ty = dyn_cast(PFTy->getElementType()))) { // Pull out the types of all of the arguments... std::vector ParamTypes; - FunctionType::ParamAttrsList ParamAttrs; - ParamAttrs.push_back($8); - for (ValueRefList::iterator I = $6->begin(), E = $6->end(); I != E; ++I) { + ParamAttrsList ParamAttrs; + if ($8 != NoAttributeSet) + ParamAttrs.addAttributes(0, $8); + ValueRefList::iterator I = $6->begin(), E = $6->end(); + unsigned index = 1; + for (; I != E; ++I, ++index) { const Type *Ty = I->Val->getType(); if (Ty == Type::VoidTy) GEN_ERROR("Short call syntax cannot be used with varargs"); ParamTypes.push_back(Ty); - ParamAttrs.push_back(I->Attrs); + if (I->Attrs != NoAttributeSet) + ParamAttrs.addAttributes(index, I->Attrs); } - Ty = FunctionType::get($3->get(), ParamTypes, false, ParamAttrs); + ParamAttrsList *Attrs = 0; + if (!ParamAttrs.empty()) + Attrs = new ParamAttrsList(ParamAttrs); + Ty = FunctionType::get($3->get(), ParamTypes, false, Attrs); PFTy = PointerType::get(Ty); } @@ -2764,17 +2791,25 @@ InstVal : ArithmeticOps Types ValueRef ',' ValueRef { !(Ty = dyn_cast(PFTy->getElementType()))) { // Pull out the types of all of the arguments... std::vector ParamTypes; - FunctionType::ParamAttrsList ParamAttrs; - ParamAttrs.push_back($8); - for (ValueRefList::iterator I = $6->begin(), E = $6->end(); I != E; ++I) { + ParamAttrsList ParamAttrs; + if ($8 != NoAttributeSet) + ParamAttrs.addAttributes(0, $8); + unsigned index = 1; + ValueRefList::iterator I = $6->begin(), E = $6->end(); + for (; I != E; ++I, ++index) { const Type *Ty = I->Val->getType(); if (Ty == Type::VoidTy) GEN_ERROR("Short call syntax cannot be used with varargs"); ParamTypes.push_back(Ty); - ParamAttrs.push_back(I->Attrs); + if (I->Attrs != NoAttributeSet) + ParamAttrs.addAttributes(index, I->Attrs); } - Ty = FunctionType::get($3->get(), ParamTypes, false, ParamAttrs); + ParamAttrsList *Attrs = 0; + if (!ParamAttrs.empty()) + Attrs = new ParamAttrsList(ParamAttrs); + + Ty = FunctionType::get($3->get(), ParamTypes, false, Attrs); PFTy = PointerType::get(Ty); } diff --git a/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp b/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp index 9df5201..045e7ab 100644 --- a/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp +++ b/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp @@ -25,6 +25,7 @@ #include "llvm/Instructions.h" #include "llvm/Intrinsics.h" #include "llvm/IntrinsicInst.h" +#include "llvm/ParameterAttributes.h" #include "llvm/CodeGen/MachineModuleInfo.h" #include "llvm/CodeGen/MachineFunction.h" #include "llvm/CodeGen/MachineFrameInfo.h" @@ -802,10 +803,11 @@ void SelectionDAGLowering::visitRet(ReturnInst &I) { else TmpVT = MVT::i32; const FunctionType *FTy = I.getParent()->getParent()->getFunctionType(); + const ParamAttrsList *Attrs = FTy->getParamAttrs(); ISD::NodeType ExtendKind = ISD::ANY_EXTEND; - if (FTy->paramHasAttr(0, FunctionType::SExtAttribute)) + if (Attrs && Attrs->paramHasAttr(0, SExtAttribute)) ExtendKind = ISD::SIGN_EXTEND; - if (FTy->paramHasAttr(0, FunctionType::ZExtAttribute)) + if (Attrs && Attrs->paramHasAttr(0, ZExtAttribute)) ExtendKind = ISD::ZERO_EXTEND; RetOp = DAG.getNode(ExtendKind, TmpVT, RetOp); } @@ -2508,6 +2510,7 @@ void SelectionDAGLowering::LowerCallTo(Instruction &I, SDOperand Callee, unsigned OpIdx) { const PointerType *PT = cast(CalledValueTy); const FunctionType *FTy = cast(PT->getElementType()); + const ParamAttrsList *Attrs = FTy->getParamAttrs(); TargetLowering::ArgListTy Args; TargetLowering::ArgListEntry Entry; @@ -2516,16 +2519,16 @@ void SelectionDAGLowering::LowerCallTo(Instruction &I, Value *Arg = I.getOperand(i); SDOperand ArgNode = getValue(Arg); Entry.Node = ArgNode; Entry.Ty = Arg->getType(); - Entry.isSExt = FTy->paramHasAttr(i, FunctionType::SExtAttribute); - Entry.isZExt = FTy->paramHasAttr(i, FunctionType::ZExtAttribute); - Entry.isInReg = FTy->paramHasAttr(i, FunctionType::InRegAttribute); - Entry.isSRet = FTy->paramHasAttr(i, FunctionType::StructRetAttribute); + Entry.isSExt = Attrs && Attrs->paramHasAttr(i, SExtAttribute); + Entry.isZExt = Attrs && Attrs->paramHasAttr(i, ZExtAttribute); + Entry.isInReg = Attrs && Attrs->paramHasAttr(i, InRegAttribute); + Entry.isSRet = Attrs && Attrs->paramHasAttr(i, StructRetAttribute); Args.push_back(Entry); } std::pair Result = TLI.LowerCallTo(getRoot(), I.getType(), - FTy->paramHasAttr(0,FunctionType::SExtAttribute), + Attrs && Attrs->paramHasAttr(0, SExtAttribute), FTy->isVarArg(), CallingConv, IsTailCall, Callee, Args, DAG); if (I.getType() != Type::VoidTy) @@ -3346,6 +3349,7 @@ static SDOperand ExpandScalarFormalArgs(MVT::ValueType VT, SDNode *Arg, std::vector TargetLowering::LowerArguments(Function &F, SelectionDAG &DAG) { const FunctionType *FTy = F.getFunctionType(); + const ParamAttrsList *Attrs = FTy->getParamAttrs(); // Add CC# and isVararg as operands to the FORMAL_ARGUMENTS node. std::vector Ops; Ops.push_back(DAG.getRoot()); @@ -3364,13 +3368,13 @@ TargetLowering::LowerArguments(Function &F, SelectionDAG &DAG) { // FIXME: Distinguish between a formal with no [sz]ext attribute from one // that is zero extended! - if (FTy->paramHasAttr(j, FunctionType::ZExtAttribute)) + if (Attrs && Attrs->paramHasAttr(j, ZExtAttribute)) Flags &= ~(ISD::ParamFlags::SExt); - if (FTy->paramHasAttr(j, FunctionType::SExtAttribute)) + if (Attrs && Attrs->paramHasAttr(j, SExtAttribute)) Flags |= ISD::ParamFlags::SExt; - if (FTy->paramHasAttr(j, FunctionType::InRegAttribute)) + if (Attrs && Attrs->paramHasAttr(j, InRegAttribute)) Flags |= ISD::ParamFlags::InReg; - if (FTy->paramHasAttr(j, FunctionType::StructRetAttribute)) + if (Attrs && Attrs->paramHasAttr(j, StructRetAttribute)) Flags |= ISD::ParamFlags::StructReturn; Flags |= (OriginalAlignment << ISD::ParamFlags::OrigAlignmentOffs); @@ -3444,10 +3448,10 @@ TargetLowering::LowerArguments(Function &F, SelectionDAG &DAG) { case Promote: { SDOperand Op(Result, i++); if (MVT::isInteger(VT)) { - if (FTy->paramHasAttr(Idx, FunctionType::SExtAttribute)) + if (Attrs && Attrs->paramHasAttr(Idx, SExtAttribute)) Op = DAG.getNode(ISD::AssertSext, Op.getValueType(), Op, DAG.getValueType(VT)); - else if (FTy->paramHasAttr(Idx, FunctionType::ZExtAttribute)) + else if (Attrs && Attrs->paramHasAttr(Idx, ZExtAttribute)) Op = DAG.getNode(ISD::AssertZext, Op.getValueType(), Op, DAG.getValueType(VT)); Op = DAG.getNode(ISD::TRUNCATE, VT, Op); diff --git a/lib/Target/CBackend/CBackend.cpp b/lib/Target/CBackend/CBackend.cpp index 6b17293..af502ce 100644 --- a/lib/Target/CBackend/CBackend.cpp +++ b/lib/Target/CBackend/CBackend.cpp @@ -18,6 +18,7 @@ #include "llvm/DerivedTypes.h" #include "llvm/Module.h" #include "llvm/Instructions.h" +#include "llvm/ParameterAttributes.h" #include "llvm/Pass.h" #include "llvm/PassManager.h" #include "llvm/TypeSymbolTable.h" @@ -350,11 +351,12 @@ void CWriter::printStructReturnPointerFunctionType(std::ostream &Out, FunctionType::param_iterator I = FTy->param_begin(), E = FTy->param_end(); const Type *RetTy = cast(I->get())->getElementType(); unsigned Idx = 1; + const ParamAttrsList *Attrs = FTy->getParamAttrs(); for (++I; I != E; ++I) { if (PrintedType) FunctionInnards << ", "; printType(FunctionInnards, *I, - /*isSigned=*/FTy->paramHasAttr(Idx, FunctionType::SExtAttribute), ""); + /*isSigned=*/Attrs && Attrs->paramHasAttr(Idx, SExtAttribute), ""); PrintedType = true; } if (FTy->isVarArg()) { @@ -366,7 +368,7 @@ void CWriter::printStructReturnPointerFunctionType(std::ostream &Out, FunctionInnards << ')'; std::string tstr = FunctionInnards.str(); printType(Out, RetTy, - /*isSigned=*/FTy->paramHasAttr(0, FunctionType::SExtAttribute), tstr); + /*isSigned=*/Attrs && Attrs->paramHasAttr(0, SExtAttribute), tstr); } std::ostream & @@ -421,13 +423,14 @@ std::ostream &CWriter::printType(std::ostream &Out, const Type *Ty, const FunctionType *FTy = cast(Ty); std::stringstream FunctionInnards; FunctionInnards << " (" << NameSoFar << ") ("; + const ParamAttrsList *Attrs = FTy->getParamAttrs(); unsigned Idx = 1; for (FunctionType::param_iterator I = FTy->param_begin(), E = FTy->param_end(); I != E; ++I) { if (I != FTy->param_begin()) FunctionInnards << ", "; printType(FunctionInnards, *I, - /*isSigned=*/FTy->paramHasAttr(Idx, FunctionType::SExtAttribute), ""); + /*isSigned=*/Attrs && Attrs->paramHasAttr(Idx, SExtAttribute), ""); ++Idx; } if (FTy->isVarArg()) { @@ -439,7 +442,7 @@ std::ostream &CWriter::printType(std::ostream &Out, const Type *Ty, FunctionInnards << ')'; std::string tstr = FunctionInnards.str(); printType(Out, FTy->getReturnType(), - /*isSigned=*/FTy->paramHasAttr(0, FunctionType::SExtAttribute), tstr); + /*isSigned=*/Attrs && Attrs->paramHasAttr(0, SExtAttribute), tstr); return Out; } case Type::StructTyID: { @@ -1801,6 +1804,7 @@ void CWriter::printFunctionSignature(const Function *F, bool Prototype) { // Loop over the arguments, printing them... const FunctionType *FT = cast(F->getFunctionType()); + const ParamAttrsList *Attrs = FT->getParamAttrs(); std::stringstream FunctionInnards; @@ -1828,7 +1832,7 @@ void CWriter::printFunctionSignature(const Function *F, bool Prototype) { else ArgName = ""; printType(FunctionInnards, I->getType(), - /*isSigned=*/FT->paramHasAttr(Idx, FunctionType::SExtAttribute), + /*isSigned=*/Attrs && Attrs->paramHasAttr(Idx, SExtAttribute), ArgName); PrintedArg = true; ++Idx; @@ -1849,7 +1853,7 @@ void CWriter::printFunctionSignature(const Function *F, bool Prototype) { for (; I != E; ++I) { if (PrintedArg) FunctionInnards << ", "; printType(FunctionInnards, *I, - /*isSigned=*/FT->paramHasAttr(Idx, FunctionType::SExtAttribute)); + /*isSigned=*/Attrs && Attrs->paramHasAttr(Idx, SExtAttribute)); PrintedArg = true; ++Idx; } @@ -1877,7 +1881,7 @@ void CWriter::printFunctionSignature(const Function *F, bool Prototype) { // Print out the return type and the signature built above. printType(Out, RetTy, - /*isSigned=*/FT->paramHasAttr(0, FunctionType::SExtAttribute), + /*isSigned=*/ Attrs && Attrs->paramHasAttr(0, SExtAttribute), FunctionInnards.str()); } @@ -2573,6 +2577,7 @@ void CWriter::visitCallInst(CallInst &I) { ++ArgNo; } + const ParamAttrsList *Attrs = FTy->getParamAttrs(); bool PrintedArg = false; unsigned Idx = 1; for (; AI != AE; ++AI, ++ArgNo, ++Idx) { @@ -2581,7 +2586,7 @@ void CWriter::visitCallInst(CallInst &I) { (*AI)->getType() != FTy->getParamType(ArgNo)) { Out << '('; printType(Out, FTy->getParamType(ArgNo), - /*isSigned=*/FTy->paramHasAttr(Idx, FunctionType::SExtAttribute)); + /*isSigned=*/Attrs && Attrs->paramHasAttr(Idx, SExtAttribute)); Out << ')'; } writeOperand(*AI); diff --git a/lib/Target/MSIL/MSILWriter.cpp b/lib/Target/MSIL/MSILWriter.cpp index bab2904..3aa05e4 100644 --- a/lib/Target/MSIL/MSILWriter.cpp +++ b/lib/Target/MSIL/MSILWriter.cpp @@ -16,6 +16,7 @@ #include "llvm/DerivedTypes.h" #include "llvm/Intrinsics.h" #include "llvm/IntrinsicInst.h" +#include "llvm/ParameterAttributes.h" #include "llvm/TypeSymbolTable.h" #include "llvm/Analysis/ConstantsScanner.h" #include "llvm/Support/CallSite.h" @@ -1131,7 +1132,8 @@ void MSILWriter::printStaticInitializerList() { void MSILWriter::printFunction(const Function& F) { const FunctionType* FTy = F.getFunctionType(); - bool isSigned = FTy->paramHasAttr(0,FunctionType::SExtAttribute); + const ParamAttrsList *Attrs = FTy->getParamAttrs(); + bool isSigned = Attrs && Attrs->paramHasAttr(0, SExtAttribute); Out << "\n.method static "; Out << (F.hasInternalLinkage() ? "private " : "public "); if (F.isVarArg()) Out << "vararg "; @@ -1142,7 +1144,7 @@ void MSILWriter::printFunction(const Function& F) { unsigned ArgIdx = 1; for (Function::const_arg_iterator I = F.arg_begin(), E = F.arg_end(); I!=E; ++I, ++ArgIdx) { - isSigned = FTy->paramHasAttr(ArgIdx,FunctionType::SExtAttribute); + isSigned = Attrs && Attrs->paramHasAttr(ArgIdx, SExtAttribute); if (I!=F.arg_begin()) Out << ", "; Out << getTypeName(I->getType(),isSigned) << getValueName(I); } -- cgit v1.1