llvm.org GIT mirror llvm / 5694b6e
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 Reid Spencer 13 years ago
5 changed file(s) with 116 addition(s) and 69 deletion(s). Raw diff Collapse all Expand all
1616
1717 #include "llvm/Constants.h"
1818 #include "llvm/DerivedTypes.h"
19 #include "llvm/ParameterAttributes.h"
1920 #include "llvm/Function.h"
2021 #include "llvm/Instructions.h"
2122 #include "llvm/Assembly/Parser.h"
230231
231232 struct TypeWithAttrs {
232233 llvm::PATypeHolder *Ty;
233 FunctionType::ParameterAttributes Attrs;
234 uint16_t Attrs;
234235 };
235236
236237 typedef std::vector TypeWithAttrsList;
237238
238239 struct ArgListEntry {
239 FunctionType::ParameterAttributes Attrs;
240 uint16_t Attrs;
240241 llvm::PATypeHolder *Ty;
241242 char *Name;
242243 };
245246
246247 struct ValueRefListEntry {
247248 Value *Val;
248 FunctionType::ParameterAttributes Attrs;
249 uint16_t Attrs;
249250 };
250251
251252 typedef std::vector ValueRefList;
199199 }
200200 return false;
201201 }
202
203
204202 } CurModule;
205203
206204 static struct PerFunctionInfo {
961959
962960 llvm::GlobalValue::LinkageTypes Linkage;
963961 llvm::GlobalValue::VisibilityTypes Visibility;
964 llvm::FunctionType::ParameterAttributes ParamAttrs;
962 uint16_t ParamAttrs;
965963 llvm::APInt *APIntVal;
966964 int64_t SInt64Val;
967965 uint64_t UInt64Val;
11901188 CHECK_FOR_ERROR
11911189 };
11921190
1193 ParamAttr : ZEXT { $$ = FunctionType::ZExtAttribute; }
1194 | SEXT { $$ = FunctionType::SExtAttribute; }
1195 | INREG { $$ = FunctionType::InRegAttribute; }
1196 | SRET { $$ = FunctionType::StructRetAttribute; }
1191 ParamAttr : ZEXT { $$ = ZExtAttribute; }
1192 | SEXT { $$ = SExtAttribute; }
1193 | INREG { $$ = InRegAttribute; }
1194 | SRET { $$ = StructRetAttribute; }
11971195 ;
11981196
1199 OptParamAttrs : /* empty */ { $$ = FunctionType::NoAttributeSet; }
1197 OptParamAttrs : /* empty */ { $$ = NoAttributeSet; }
12001198 | OptParamAttrs ParamAttr {
1201 $$ = FunctionType::ParameterAttributes($1 | $2);
1199 $$ = $1 | $2;
12021200 }
12031201 ;
12041202
1205 FuncAttr : NORETURN { $$ = FunctionType::NoReturnAttribute; }
1206 | NOUNWIND { $$ = FunctionType::NoUnwindAttribute; }
1203 FuncAttr : NORETURN { $$ = NoReturnAttribute; }
1204 | NOUNWIND { $$ = NoUnwindAttribute; }
12071205 | ParamAttr
12081206 ;
12091207
1210 OptFuncAttrs : /* empty */ { $$ = FunctionType::NoAttributeSet; }
1208 OptFuncAttrs : /* empty */ { $$ = NoAttributeSet; }
12111209 | OptFuncAttrs FuncAttr {
1212 $$ = FunctionType::ParameterAttributes($1 | $2);
1210 $$ = $1 | $2;
12131211 }
12141212 ;
12151213
12981296 }
12991297 | Types '(' ArgTypeListI ')' OptFuncAttrs {
13001298 std::vector Params;
1301 std::vector Attrs;
1302 Attrs.push_back($5);
1303 for (TypeWithAttrsList::iterator I=$3->begin(), E=$3->end(); I != E; ++I) {
1299 ParamAttrsList Attrs;
1300 if ($5 != NoAttributeSet)
1301 Attrs.addAttributes(0, $5);
1302 unsigned index = 1;
1303 TypeWithAttrsList::iterator I = $3->begin(), E = $3->end();
1304 for (; I != E; ++I, ++index) {
13041305 const Type *Ty = I->Ty->get();
13051306 Params.push_back(Ty);
13061307 if (Ty != Type::VoidTy)
1307 Attrs.push_back(I->Attrs);
1308 if (I->Attrs != NoAttributeSet)
1309 Attrs.addAttributes(index, I->Attrs);
13081310 }
13091311 bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
13101312 if (isVarArg) Params.pop_back();
13111313
1312 FunctionType *FT = FunctionType::get(*$1, Params, isVarArg, Attrs);
1314 ParamAttrsList *ActualAttrs = 0;
1315 if (!Attrs.empty())
1316 ActualAttrs = new ParamAttrsList(Attrs);
1317 FunctionType *FT = FunctionType::get(*$1, Params, isVarArg, ActualAttrs);
13131318 delete $3; // Delete the argument list
13141319 delete $1; // Delete the return type handle
13151320 $$ = new PATypeHolder(HandleUpRefs(FT));
13171322 }
13181323 | VOID '(' ArgTypeListI ')' OptFuncAttrs {
13191324 std::vector Params;
1320 std::vector Attrs;
1321 Attrs.push_back($5);
1322 for (TypeWithAttrsList::iterator I=$3->begin(), E=$3->end(); I != E; ++I) {
1325 ParamAttrsList Attrs;
1326 if ($5 != NoAttributeSet)
1327 Attrs.addAttributes(0, $5);
1328 TypeWithAttrsList::iterator I = $3->begin(), E = $3->end();
1329 unsigned index = 1;
1330 for ( ; I != E; ++I, ++index) {
13231331 const Type* Ty = I->Ty->get();
13241332 Params.push_back(Ty);
13251333 if (Ty != Type::VoidTy)
1326 Attrs.push_back(I->Attrs);
1334 if (I->Attrs != NoAttributeSet)
1335 Attrs.addAttributes(index, I->Attrs);
13271336 }
13281337 bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
13291338 if (isVarArg) Params.pop_back();
13301339
1331 FunctionType *FT = FunctionType::get($1, Params, isVarArg, Attrs);
1340 ParamAttrsList *ActualAttrs = 0;
1341 if (!Attrs.empty())
1342 ActualAttrs = new ParamAttrsList(Attrs);
1343
1344 FunctionType *FT = FunctionType::get($1, Params, isVarArg, ActualAttrs);
13321345 delete $3; // Delete the argument list
13331346 $$ = new PATypeHolder(HandleUpRefs(FT));
13341347 CHECK_FOR_ERROR
14161429 : ArgTypeList
14171430 | ArgTypeList ',' DOTDOTDOT {
14181431 $$=$1;
1419 TypeWithAttrs TWA; TWA.Attrs = FunctionType::NoAttributeSet;
1432 TypeWithAttrs TWA; TWA.Attrs = NoAttributeSet;
14201433 TWA.Ty = new PATypeHolder(Type::VoidTy);
14211434 $$->push_back(TWA);
14221435 CHECK_FOR_ERROR
14231436 }
14241437 | DOTDOTDOT {
14251438 $$ = new TypeWithAttrsList;
1426 TypeWithAttrs TWA; TWA.Attrs = FunctionType::NoAttributeSet;
1439 TypeWithAttrs TWA; TWA.Attrs = NoAttributeSet;
14271440 TWA.Ty = new PATypeHolder(Type::VoidTy);
14281441 $$->push_back(TWA);
14291442 CHECK_FOR_ERROR
20862099 struct ArgListEntry E;
20872100 E.Ty = new PATypeHolder(Type::VoidTy);
20882101 E.Name = 0;
2089 E.Attrs = FunctionType::NoAttributeSet;
2102 E.Attrs = NoAttributeSet;
20902103 $$->push_back(E);
20912104 CHECK_FOR_ERROR
20922105 }
20952108 struct ArgListEntry E;
20962109 E.Ty = new PATypeHolder(Type::VoidTy);
20972110 E.Name = 0;
2098 E.Attrs = FunctionType::NoAttributeSet;
2111 E.Attrs = NoAttributeSet;
20992112 $$->push_back(E);
21002113 CHECK_FOR_ERROR
21012114 }
21162129 GEN_ERROR("Reference to abstract result: "+ $2->get()->getDescription());
21172130
21182131 std::vector ParamTypeList;
2119 std::vector ParamAttrs;
2120 ParamAttrs.push_back($7);
2132 ParamAttrsList ParamAttrs;
2133 if ($7 != NoAttributeSet)
2134 ParamAttrs.addAttributes(0, $7);
21212135 if ($5) { // If there are arguments...
2122 for (ArgListType::iterator I = $5->begin(); I != $5->end(); ++I) {
2136 unsigned index = 1;
2137 for (ArgListType::iterator I = $5->begin(); I != $5->end(); ++I, ++index) {
21232138 const Type* Ty = I->Ty->get();
21242139 if (!CurFun.isDeclare && CurModule.TypeIsUnresolved(I->Ty))
21252140 GEN_ERROR("Reference to abstract argument: " + Ty->getDescription());
21262141 ParamTypeList.push_back(Ty);
21272142 if (Ty != Type::VoidTy)
2128 ParamAttrs.push_back(I->Attrs);
2143 if (I->Attrs != NoAttributeSet)
2144 ParamAttrs.addAttributes(index, I->Attrs);
21292145 }
21302146 }
21312147
21322148 bool isVarArg = ParamTypeList.size() && ParamTypeList.back() == Type::VoidTy;
21332149 if (isVarArg) ParamTypeList.pop_back();
21342150
2135 FunctionType *FT = FunctionType::get(*$2, ParamTypeList, isVarArg,
2136 ParamAttrs);
2151 ParamAttrsList *ActualAttrs = 0;
2152 if (!ParamAttrs.empty())
2153 ActualAttrs = new ParamAttrsList(ParamAttrs);
2154
2155 FunctionType *FT = FunctionType::get(*$2, ParamTypeList, isVarArg,
2156 ActualAttrs);
21372157 const PointerType *PFT = PointerType::get(FT);
21382158 delete $2;
21392159
24642484 !(Ty = dyn_cast(PFTy->getElementType()))) {
24652485 // Pull out the types of all of the arguments...
24662486 std::vector ParamTypes;
2467 FunctionType::ParamAttrsList ParamAttrs;
2468 ParamAttrs.push_back($8);
2469 for (ValueRefList::iterator I = $6->begin(), E = $6->end(); I != E; ++I) {
2487 ParamAttrsList ParamAttrs;
2488 if ($8 != NoAttributeSet)
2489 ParamAttrs.addAttributes(0, $8);
2490 ValueRefList::iterator I = $6->begin(), E = $6->end();
2491 unsigned index = 1;
2492 for (; I != E; ++I, ++index) {
24702493 const Type *Ty = I->Val->getType();
24712494 if (Ty == Type::VoidTy)
24722495 GEN_ERROR("Short call syntax cannot be used with varargs");
24732496 ParamTypes.push_back(Ty);
2474 ParamAttrs.push_back(I->Attrs);
2497 if (I->Attrs != NoAttributeSet)
2498 ParamAttrs.addAttributes(index, I->Attrs);
24752499 }
24762500
2477 Ty = FunctionType::get($3->get(), ParamTypes, false, ParamAttrs);
2501 ParamAttrsList *Attrs = 0;
2502 if (!ParamAttrs.empty())
2503 Attrs = new ParamAttrsList(ParamAttrs);
2504 Ty = FunctionType::get($3->get(), ParamTypes, false, Attrs);
24782505 PFTy = PointerType::get(Ty);
24792506 }
24802507
27632790 !(Ty = dyn_cast(PFTy->getElementType()))) {
27642791 // Pull out the types of all of the arguments...
27652792 std::vector ParamTypes;
2766 FunctionType::ParamAttrsList ParamAttrs;
2767 ParamAttrs.push_back($8);
2768 for (ValueRefList::iterator I = $6->begin(), E = $6->end(); I != E; ++I) {
2793 ParamAttrsList ParamAttrs;
2794 if ($8 != NoAttributeSet)
2795 ParamAttrs.addAttributes(0, $8);
2796 unsigned index = 1;
2797 ValueRefList::iterator I = $6->begin(), E = $6->end();
2798 for (; I != E; ++I, ++index) {
27692799 const Type *Ty = I->Val->getType();
27702800 if (Ty == Type::VoidTy)
27712801 GEN_ERROR("Short call syntax cannot be used with varargs");
27722802 ParamTypes.push_back(Ty);
2773 ParamAttrs.push_back(I->Attrs);
2803 if (I->Attrs != NoAttributeSet)
2804 ParamAttrs.addAttributes(index, I->Attrs);
27742805 }
27752806
2776 Ty = FunctionType::get($3->get(), ParamTypes, false, ParamAttrs);
2807 ParamAttrsList *Attrs = 0;
2808 if (!ParamAttrs.empty())
2809 Attrs = new ParamAttrsList(ParamAttrs);
2810
2811 Ty = FunctionType::get($3->get(), ParamTypes, false, Attrs);
27772812 PFTy = PointerType::get(Ty);
27782813 }
27792814
2424 #include "llvm/Instructions.h"
2525 #include "llvm/Intrinsics.h"
2626 #include "llvm/IntrinsicInst.h"
27 #include "llvm/ParameterAttributes.h"
2728 #include "llvm/CodeGen/MachineModuleInfo.h"
2829 #include "llvm/CodeGen/MachineFunction.h"
2930 #include "llvm/CodeGen/MachineFrameInfo.h"
801802 else
802803 TmpVT = MVT::i32;
803804 const FunctionType *FTy = I.getParent()->getParent()->getFunctionType();
805 const ParamAttrsList *Attrs = FTy->getParamAttrs();
804806 ISD::NodeType ExtendKind = ISD::ANY_EXTEND;
805 if (FTy->paramHasAttr(0, FunctionType::SExtAttribute))
807 if (Attrs && Attrs->paramHasAttr(0, SExtAttribute))
806808 ExtendKind = ISD::SIGN_EXTEND;
807 if (FTy->paramHasAttr(0, FunctionType::ZExtAttribute))
809 if (Attrs && Attrs->paramHasAttr(0, ZExtAttribute))
808810 ExtendKind = ISD::ZERO_EXTEND;
809811 RetOp = DAG.getNode(ExtendKind, TmpVT, RetOp);
810812 }
25072509 SDOperand Callee, unsigned OpIdx) {
25082510 const PointerType *PT = cast(CalledValueTy);
25092511 const FunctionType *FTy = cast(PT->getElementType());
2512 const ParamAttrsList *Attrs = FTy->getParamAttrs();
25102513
25112514 TargetLowering::ArgListTy Args;
25122515 TargetLowering::ArgListEntry Entry;
25152518 Value *Arg = I.getOperand(i);
25162519 SDOperand ArgNode = getValue(Arg);
25172520 Entry.Node = ArgNode; Entry.Ty = Arg->getType();
2518 Entry.isSExt = FTy->paramHasAttr(i, FunctionType::SExtAttribute);
2519 Entry.isZExt = FTy->paramHasAttr(i, FunctionType::ZExtAttribute);
2520 Entry.isInReg = FTy->paramHasAttr(i, FunctionType::InRegAttribute);
2521 Entry.isSRet = FTy->paramHasAttr(i, FunctionType::StructRetAttribute);
2521 Entry.isSExt = Attrs && Attrs->paramHasAttr(i, SExtAttribute);
2522 Entry.isZExt = Attrs && Attrs->paramHasAttr(i, ZExtAttribute);
2523 Entry.isInReg = Attrs && Attrs->paramHasAttr(i, InRegAttribute);
2524 Entry.isSRet = Attrs && Attrs->paramHasAttr(i, StructRetAttribute);
25222525 Args.push_back(Entry);
25232526 }
25242527
25252528 std::pair Result =
25262529 TLI.LowerCallTo(getRoot(), I.getType(),
2527 FTy->paramHasAttr(0,FunctionType::SExtAttribute),
2530 Attrs && Attrs->paramHasAttr(0, SExtAttribute),
25282531 FTy->isVarArg(), CallingConv, IsTailCall,
25292532 Callee, Args, DAG);
25302533 if (I.getType() != Type::VoidTy)
33453348 std::vector
33463349 TargetLowering::LowerArguments(Function &F, SelectionDAG &DAG) {
33473350 const FunctionType *FTy = F.getFunctionType();
3351 const ParamAttrsList *Attrs = FTy->getParamAttrs();
33483352 // Add CC# and isVararg as operands to the FORMAL_ARGUMENTS node.
33493353 std::vector Ops;
33503354 Ops.push_back(DAG.getRoot());
33633367
33643368 // FIXME: Distinguish between a formal with no [sz]ext attribute from one
33653369 // that is zero extended!
3366 if (FTy->paramHasAttr(j, FunctionType::ZExtAttribute))
3370 if (Attrs && Attrs->paramHasAttr(j, ZExtAttribute))
33673371 Flags &= ~(ISD::ParamFlags::SExt);
3368 if (FTy->paramHasAttr(j, FunctionType::SExtAttribute))
3372 if (Attrs && Attrs->paramHasAttr(j, SExtAttribute))
33693373 Flags |= ISD::ParamFlags::SExt;
3370 if (FTy->paramHasAttr(j, FunctionType::InRegAttribute))
3374 if (Attrs && Attrs->paramHasAttr(j, InRegAttribute))
33713375 Flags |= ISD::ParamFlags::InReg;
3372 if (FTy->paramHasAttr(j, FunctionType::StructRetAttribute))
3376 if (Attrs && Attrs->paramHasAttr(j, StructRetAttribute))
33733377 Flags |= ISD::ParamFlags::StructReturn;
33743378 Flags |= (OriginalAlignment << ISD::ParamFlags::OrigAlignmentOffs);
33753379
34433447 case Promote: {
34443448 SDOperand Op(Result, i++);
34453449 if (MVT::isInteger(VT)) {
3446 if (FTy->paramHasAttr(Idx, FunctionType::SExtAttribute))
3450 if (Attrs && Attrs->paramHasAttr(Idx, SExtAttribute))
34473451 Op = DAG.getNode(ISD::AssertSext, Op.getValueType(), Op,
34483452 DAG.getValueType(VT));
3449 else if (FTy->paramHasAttr(Idx, FunctionType::ZExtAttribute))
3453 else if (Attrs && Attrs->paramHasAttr(Idx, ZExtAttribute))
34503454 Op = DAG.getNode(ISD::AssertZext, Op.getValueType(), Op,
34513455 DAG.getValueType(VT));
34523456 Op = DAG.getNode(ISD::TRUNCATE, VT, Op);
1717 #include "llvm/DerivedTypes.h"
1818 #include "llvm/Module.h"
1919 #include "llvm/Instructions.h"
20 #include "llvm/ParameterAttributes.h"
2021 #include "llvm/Pass.h"
2122 #include "llvm/PassManager.h"
2223 #include "llvm/TypeSymbolTable.h"
349350 FunctionType::param_iterator I = FTy->param_begin(), E = FTy->param_end();
350351 const Type *RetTy = cast(I->get())->getElementType();
351352 unsigned Idx = 1;
353 const ParamAttrsList *Attrs = FTy->getParamAttrs();
352354 for (++I; I != E; ++I) {
353355 if (PrintedType)
354356 FunctionInnards << ", ";
355357 printType(FunctionInnards, *I,
356 /*isSigned=*/FTy->paramHasAttr(Idx, FunctionType::SExtAttribute), "");
358 /*isSigned=*/Attrs && Attrs->paramHasAttr(Idx, SExtAttribute), "");
357359 PrintedType = true;
358360 }
359361 if (FTy->isVarArg()) {
365367 FunctionInnards << ')';
366368 std::string tstr = FunctionInnards.str();
367369 printType(Out, RetTy,
368 /*isSigned=*/FTy->paramHasAttr(0, FunctionType::SExtAttribute), tstr);
370 /*isSigned=*/Attrs && Attrs->paramHasAttr(0, SExtAttribute), tstr);
369371 }
370372
371373 std::ostream &
420422 const FunctionType *FTy = cast(Ty);
421423 std::stringstream FunctionInnards;
422424 FunctionInnards << " (" << NameSoFar << ") (";
425 const ParamAttrsList *Attrs = FTy->getParamAttrs();
423426 unsigned Idx = 1;
424427 for (FunctionType::param_iterator I = FTy->param_begin(),
425428 E = FTy->param_end(); I != E; ++I) {
426429 if (I != FTy->param_begin())
427430 FunctionInnards << ", ";
428431 printType(FunctionInnards, *I,
429 /*isSigned=*/FTy->paramHasAttr(Idx, FunctionType::SExtAttribute), "");
432 /*isSigned=*/Attrs && Attrs->paramHasAttr(Idx, SExtAttribute), "");
430433 ++Idx;
431434 }
432435 if (FTy->isVarArg()) {
438441 FunctionInnards << ')';
439442 std::string tstr = FunctionInnards.str();
440443 printType(Out, FTy->getReturnType(),
441 /*isSigned=*/FTy->paramHasAttr(0, FunctionType::SExtAttribute), tstr);
444 /*isSigned=*/Attrs && Attrs->paramHasAttr(0, SExtAttribute), tstr);
442445 return Out;
443446 }
444447 case Type::StructTyID: {
18001803
18011804 // Loop over the arguments, printing them...
18021805 const FunctionType *FT = cast(F->getFunctionType());
1806 const ParamAttrsList *Attrs = FT->getParamAttrs();
18031807
18041808 std::stringstream FunctionInnards;
18051809
18271831 else
18281832 ArgName = "";
18291833 printType(FunctionInnards, I->getType(),
1830 /*isSigned=*/FT->paramHasAttr(Idx, FunctionType::SExtAttribute),
1834 /*isSigned=*/Attrs && Attrs->paramHasAttr(Idx, SExtAttribute),
18311835 ArgName);
18321836 PrintedArg = true;
18331837 ++Idx;
18481852 for (; I != E; ++I) {
18491853 if (PrintedArg) FunctionInnards << ", ";
18501854 printType(FunctionInnards, *I,
1851 /*isSigned=*/FT->paramHasAttr(Idx, FunctionType::SExtAttribute));
1855 /*isSigned=*/Attrs && Attrs->paramHasAttr(Idx, SExtAttribute));
18521856 PrintedArg = true;
18531857 ++Idx;
18541858 }
18761880
18771881 // Print out the return type and the signature built above.
18781882 printType(Out, RetTy,
1879 /*isSigned=*/FT->paramHasAttr(0, FunctionType::SExtAttribute),
1883 /*isSigned=*/ Attrs && Attrs->paramHasAttr(0, SExtAttribute),
18801884 FunctionInnards.str());
18811885 }
18821886
25722576 ++ArgNo;
25732577 }
25742578
2579 const ParamAttrsList *Attrs = FTy->getParamAttrs();
25752580 bool PrintedArg = false;
25762581 unsigned Idx = 1;
25772582 for (; AI != AE; ++AI, ++ArgNo, ++Idx) {
25802585 (*AI)->getType() != FTy->getParamType(ArgNo)) {
25812586 Out << '(';
25822587 printType(Out, FTy->getParamType(ArgNo),
2583 /*isSigned=*/FTy->paramHasAttr(Idx, FunctionType::SExtAttribute));
2588 /*isSigned=*/Attrs && Attrs->paramHasAttr(Idx, SExtAttribute));
25842589 Out << ')';
25852590 }
25862591 writeOperand(*AI);
1515 #include "llvm/DerivedTypes.h"
1616 #include "llvm/Intrinsics.h"
1717 #include "llvm/IntrinsicInst.h"
18 #include "llvm/ParameterAttributes.h"
1819 #include "llvm/TypeSymbolTable.h"
1920 #include "llvm/Analysis/ConstantsScanner.h"
2021 #include "llvm/Support/CallSite.h"
11301131
11311132 void MSILWriter::printFunction(const Function& F) {
11321133 const FunctionType* FTy = F.getFunctionType();
1133 bool isSigned = FTy->paramHasAttr(0,FunctionType::SExtAttribute);
1134 const ParamAttrsList *Attrs = FTy->getParamAttrs();
1135 bool isSigned = Attrs && Attrs->paramHasAttr(0, SExtAttribute);
11341136 Out << "\n.method static ";
11351137 Out << (F.hasInternalLinkage() ? "private " : "public ");
11361138 if (F.isVarArg()) Out << "vararg ";
11411143 unsigned ArgIdx = 1;
11421144 for (Function::const_arg_iterator I = F.arg_begin(), E = F.arg_end(); I!=E;
11431145 ++I, ++ArgIdx) {
1144 isSigned = FTy->paramHasAttr(ArgIdx,FunctionType::SExtAttribute);
1146 isSigned = Attrs && Attrs->paramHasAttr(ArgIdx, SExtAttribute);
11451147 if (I!=F.arg_begin()) Out << ", ";
11461148 Out << getTypeName(I->getType(),isSigned) << getValueName(I);
11471149 }