Use the attribute enums to query if a parameter has an attribute.

llvm-svn: 165550

llvm/include/llvm/Attributes.h

@@ -295,7 +295,7 @@ public:
   static Attributes constructAlignmentFromInt(unsigned i) {
     // Default alignment, allow the target to define how to align it.
     if (i == 0)
-      return Attribute::None;
+      return Attributes();
 
     assert(isPowerOf2_32(i) && "Alignment must be a power of two.");
     assert(i <= 0x40000000 && "Alignment too large.");
@@ -307,7 +307,7 @@ public:
   static Attributes constructStackAlignmentFromInt(unsigned i) {
     // Default alignment, allow the target to define how to align it.
     if (i == 0)
-      return Attribute::None;
+      return Attributes();
 
     assert(isPowerOf2_32(i) && "Alignment must be a power of two.");
     assert(i <= 0x100 && "Alignment too large.");

llvm/include/llvm/Instructions.h

@@ -1277,14 +1277,7 @@ public:
   bool fnHasReturnsTwiceAttr() const;
 
   /// @brief Determine whether the call or the callee has the given attributes.
-  bool paramHasByValAttr(unsigned i) const;
+  bool paramHasAttr(unsigned i, Attributes::AttrVal A) const;
-  bool paramHasInRegAttr(unsigned i) const;
-  bool paramHasNestAttr(unsigned i) const;
-  bool paramHasNoAliasAttr(unsigned i) const;
-  bool paramHasNoCaptureAttr(unsigned i) const;
-  bool paramHasSExtAttr(unsigned i) const;
-  bool paramHasStructRetAttr(unsigned i) const;
-  bool paramHasZExtAttr(unsigned i) const;
 
   /// @brief Extract the alignment for a call or parameter (0=unknown).
   unsigned getParamAlignment(unsigned i) const {
@@ -1343,7 +1336,7 @@ public:
   /// pointer argument.
   bool hasStructRetAttr() const {
     // Be friendly and also check the callee.
-    return paramHasStructRetAttr(1);
+    return paramHasAttr(1, Attributes::StructRet);
   }
 
   /// @brief Determine if any call argument is an aggregate passed by value.
@@ -3053,14 +3046,7 @@ public:
   bool fnHasReturnsTwiceAttr() const;
 
   /// @brief Determine whether the call or the callee has the given attributes.
-  bool paramHasSExtAttr(unsigned i) const;
+  bool paramHasAttr(unsigned i, Attributes::AttrVal A) const;
-  bool paramHasZExtAttr(unsigned i) const;
-  bool paramHasInRegAttr(unsigned i) const;
-  bool paramHasStructRetAttr(unsigned i) const;
-  bool paramHasNestAttr(unsigned i) const;
-  bool paramHasByValAttr(unsigned i) const;
-  bool paramHasNoAliasAttr(unsigned i) const;
-  bool paramHasNoCaptureAttr(unsigned i) const;
 
   /// @brief Extract the alignment for a call or parameter (0=unknown).
   unsigned getParamAlignment(unsigned i) const {
@@ -3110,7 +3096,7 @@ public:
   /// pointer argument.
   bool hasStructRetAttr() const {
     // Be friendly and also check the callee.
-    return paramHasStructRetAttr(1);
+    return paramHasAttr(1, Attributes::StructRet);
   }
 
   /// @brief Determine if any call argument is an aggregate passed by value.

llvm/include/llvm/Support/CallSite.h

@@ -210,35 +210,9 @@ public:
     CALLSITE_DELEGATE_GETTER(hasFnAttr(N));
   }
 
-  /// paramHas*Attr - whether the call or the callee has the given attribute.
+  /// \brief Return true if the call or the callee has the given attribute.
-  bool paramHasSExtAttr(unsigned i) const {
+  bool paramHasAttr(unsigned i, Attributes::AttrVal A) const {
-    CALLSITE_DELEGATE_GETTER(paramHasSExtAttr(i));
+    CALLSITE_DELEGATE_GETTER(paramHasAttr(i, A));
-  }
-  bool paramHasZExtAttr(unsigned i) const {
-    CALLSITE_DELEGATE_GETTER(paramHasZExtAttr(i));
-  }
-  bool paramHasInRegAttr(unsigned i) const {
-    CALLSITE_DELEGATE_GETTER(paramHasInRegAttr(i));
-  }
-  bool paramHasStructRetAttr(unsigned i) const {
-    CALLSITE_DELEGATE_GETTER(paramHasStructRetAttr(i));
-  }
-  bool paramHasNestAttr(unsigned i) const {
-    CALLSITE_DELEGATE_GETTER(paramHasNestAttr(i));
-  }
-  bool paramHasByValAttr(unsigned i) const {
-    CALLSITE_DELEGATE_GETTER(paramHasByValAttr(i));
-  }
-  bool paramHasNoAliasAttr(unsigned i) const {
-    CALLSITE_DELEGATE_GETTER(paramHasNoAliasAttr(i));
-  }
-  bool paramHasNoCaptureAttr(unsigned i) const {
-    CALLSITE_DELEGATE_GETTER(paramHasNoCaptureAttr(i));
-  }
-
-  /// paramHasAttr - whether the call or the callee has the given attribute.
-  bool paramHasAttr(uint16_t i, Attributes attr) const {
-    CALLSITE_DELEGATE_GETTER(paramHasAttr(i, attr));
   }
 
   /// @brief Extract the alignment for a call or parameter (0=unknown).
@@ -291,12 +265,12 @@ public:
 
   /// @brief Determine whether this argument is not captured.
   bool doesNotCapture(unsigned ArgNo) const {
-    return paramHasNoCaptureAttr(ArgNo + 1);
+    return paramHasAttr(ArgNo + 1, Attributes::NoCapture);
   }
 
   /// @brief Determine whether this argument is passed by value.
   bool isByValArgument(unsigned ArgNo) const {
-    return paramHasByValAttr(ArgNo + 1);
+    return paramHasAttr(ArgNo + 1, Attributes::ByVal);
   }
 
   /// hasArgument - Returns true if this CallSite passes the given Value* as an

llvm/include/llvm/Target/TargetLowering.h

@@ -1323,9 +1323,9 @@ public:
                      FunctionType *FTy, bool isTailCall, SDValue callee,
                      ArgListTy &args, SelectionDAG &dag, DebugLoc dl,
                      ImmutableCallSite &cs)
-    : Chain(chain), RetTy(retTy), RetSExt(cs.paramHasSExtAttr(0)),
+    : Chain(chain), RetTy(retTy), RetSExt(cs.paramHasAttr(0, Attributes::SExt)),
-      RetZExt(cs.paramHasZExtAttr(0)), IsVarArg(FTy->isVarArg()),
+      RetZExt(cs.paramHasAttr(0, Attributes::ZExt)), IsVarArg(FTy->isVarArg()),
-      IsInReg(cs.paramHasInRegAttr(0)),
+      IsInReg(cs.paramHasAttr(0, Attributes::InReg)),
       DoesNotReturn(cs.doesNotReturn()),
       IsReturnValueUsed(!cs.getInstruction()->use_empty()),
       IsTailCall(isTailCall), NumFixedArgs(FTy->getNumParams()),

llvm/lib/Analysis/AliasAnalysis.cpp

@@ -503,7 +503,7 @@ bool AliasAnalysis::canInstructionRangeModify(const Instruction &I1,
 bool llvm::isNoAliasCall(const Value *V) {
   if (isa<CallInst>(V) || isa<InvokeInst>(V))
     return ImmutableCallSite(cast<Instruction>(V))
-      .paramHasNoAliasAttr(0);
+      .paramHasAttr(0, Attributes::NoAlias);
   return false;
 }
 

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

@@ -5342,12 +5342,12 @@ void SelectionDAGBuilder::LowerCallTo(ImmutableCallSite CS, SDValue Callee,
     Entry.Node = ArgNode; Entry.Ty = V->getType();
 
     unsigned attrInd = i - CS.arg_begin() + 1;
-    Entry.isSExt  = CS.paramHasSExtAttr(attrInd);
+    Entry.isSExt  = CS.paramHasAttr(attrInd, Attributes::SExt);
-    Entry.isZExt  = CS.paramHasZExtAttr(attrInd);
+    Entry.isZExt  = CS.paramHasAttr(attrInd, Attributes::ZExt);
-    Entry.isInReg = CS.paramHasInRegAttr(attrInd);
+    Entry.isInReg = CS.paramHasAttr(attrInd, Attributes::InReg);
-    Entry.isSRet  = CS.paramHasStructRetAttr(attrInd);
+    Entry.isSRet  = CS.paramHasAttr(attrInd, Attributes::StructRet);
-    Entry.isNest  = CS.paramHasNestAttr(attrInd);
+    Entry.isNest  = CS.paramHasAttr(attrInd, Attributes::Nest);
-    Entry.isByVal = CS.paramHasByValAttr(attrInd);
+    Entry.isByVal = CS.paramHasAttr(attrInd, Attributes::ByVal);
     Entry.Alignment = CS.getParamAlignment(attrInd);
     Args.push_back(Entry);
   }

llvm/lib/Target/ARM/ARMFastISel.cpp

@@ -2320,16 +2320,16 @@ bool ARMFastISel::SelectCall(const Instruction *I,
 
     ISD::ArgFlagsTy Flags;
     unsigned AttrInd = i - CS.arg_begin() + 1;
-    if (CS.paramHasSExtAttr(AttrInd))
+    if (CS.paramHasAttr(AttrInd, Attributes::SExt))
       Flags.setSExt();
-    if (CS.paramHasZExtAttr(AttrInd))
+    if (CS.paramHasAttr(AttrInd, Attributes::ZExt))
       Flags.setZExt();
 
     // FIXME: Only handle *easy* calls for now.
-    if (CS.paramHasInRegAttr(AttrInd) ||
+    if (CS.paramHasAttr(AttrInd, Attributes::InReg) ||
-        CS.paramHasStructRetAttr(AttrInd) ||
+        CS.paramHasAttr(AttrInd, Attributes::StructRet) ||
-        CS.paramHasNestAttr(AttrInd) ||
+        CS.paramHasAttr(AttrInd, Attributes::Nest) ||
-        CS.paramHasByValAttr(AttrInd))
+        CS.paramHasAttr(AttrInd, Attributes::ByVal))
       return false;
 
     Type *ArgTy = (*i)->getType();

llvm/lib/Target/X86/X86FastISel.cpp

@@ -1541,9 +1541,9 @@ static unsigned computeBytesPoppedByCallee(const X86Subtarget &Subtarget,
   CallingConv::ID CC = CS.getCallingConv();
   if (CC == CallingConv::Fast || CC == CallingConv::GHC)
     return 0;
-  if (!CS.paramHasStructRetAttr(1))
+  if (!CS.paramHasAttr(1, Attributes::StructRet))
     return 0;
-  if (CS.paramHasInRegAttr(1))
+  if (CS.paramHasAttr(1, Attributes::InReg))
     return 0;
   return 4;
 }
@@ -1622,12 +1622,12 @@ bool X86FastISel::DoSelectCall(const Instruction *I, const char *MemIntName) {
     Value *ArgVal = *i;
     ISD::ArgFlagsTy Flags;
     unsigned AttrInd = i - CS.arg_begin() + 1;
-    if (CS.paramHasSExtAttr(AttrInd))
+    if (CS.paramHasAttr(AttrInd, Attributes::SExt))
       Flags.setSExt();
-    if (CS.paramHasZExtAttr(AttrInd))
+    if (CS.paramHasAttr(AttrInd, Attributes::ZExt))
       Flags.setZExt();
 
-    if (CS.paramHasByValAttr(AttrInd)) {
+    if (CS.paramHasAttr(AttrInd, Attributes::ByVal)) {
       PointerType *Ty = cast<PointerType>(ArgVal->getType());
       Type *ElementTy = Ty->getElementType();
       unsigned FrameSize = TD.getTypeAllocSize(ElementTy);
@@ -1641,9 +1641,9 @@ bool X86FastISel::DoSelectCall(const Instruction *I, const char *MemIntName) {
         return false;
     }
 
-    if (CS.paramHasInRegAttr(AttrInd))
+    if (CS.paramHasAttr(AttrInd, Attributes::InReg))
       Flags.setInReg();
-    if (CS.paramHasNestAttr(AttrInd))
+    if (CS.paramHasAttr(AttrInd, Attributes::Nest))
       Flags.setNest();
 
     // If this is an i1/i8/i16 argument, promote to i32 to avoid an extra
@@ -1911,11 +1911,11 @@ bool X86FastISel::DoSelectCall(const Instruction *I, const char *MemIntName) {
       ISD::InputArg MyFlags;
       MyFlags.VT = RegisterVT.getSimpleVT();
       MyFlags.Used = !CS.getInstruction()->use_empty();
-      if (CS.paramHasSExtAttr(0))
+      if (CS.paramHasAttr(0, Attributes::SExt))
         MyFlags.Flags.setSExt();
-      if (CS.paramHasZExtAttr(0))
+      if (CS.paramHasAttr(0, Attributes::ZExt))
         MyFlags.Flags.setZExt();
-      if (CS.paramHasInRegAttr(0))
+      if (CS.paramHasAttr(0, Attributes::InReg))
         MyFlags.Flags.setInReg();
       Ins.push_back(MyFlags);
     }

llvm/lib/Transforms/IPO/FunctionAttrs.cpp

@@ -518,7 +518,7 @@ bool FunctionAttrs::IsFunctionMallocLike(Function *F,
         case Instruction::Call:
         case Instruction::Invoke: {
           CallSite CS(RVI);
-          if (CS.paramHasNoAliasAttr(0))
+          if (CS.paramHasAttr(0, Attributes::NoAlias))
             break;
           if (CS.getCalledFunction() &&
               SCCNodes.count(CS.getCalledFunction()))

llvm/lib/VMCore/Instructions.cpp

@@ -393,67 +393,11 @@ bool CallInst::fnHasReturnsTwiceAttr() const {
   return false;
 }
 
-bool CallInst::paramHasSExtAttr(unsigned i) const {
+bool CallInst::paramHasAttr(unsigned i, Attributes::AttrVal A) const {
-  if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::SExt))
+  if (AttributeList.getParamAttributes(i).hasAttribute(A))
     return true;
   if (const Function *F = getCalledFunction())
-    return F->getParamAttributes(i).hasAttribute(Attributes::SExt);
+    return F->getParamAttributes(i).hasAttribute(A);
-  return false;
-}
-
-bool CallInst::paramHasZExtAttr(unsigned i) const {
-  if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::ZExt))
-    return true;
-  if (const Function *F = getCalledFunction())
-    return F->getParamAttributes(i).hasAttribute(Attributes::ZExt);
-  return false;
-}
-
-bool CallInst::paramHasInRegAttr(unsigned i) const {
-  if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::InReg))
-    return true;
-  if (const Function *F = getCalledFunction())
-    return F->getParamAttributes(i).hasAttribute(Attributes::InReg);
-  return false;
-}
-
-bool CallInst::paramHasStructRetAttr(unsigned i) const {
-  if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::StructRet))
-    return true;
-  if (const Function *F = getCalledFunction())
-    return F->getParamAttributes(i).hasAttribute(Attributes::StructRet);
-  return false;
-}
-
-bool CallInst::paramHasNestAttr(unsigned i) const {
-  if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::Nest))
-    return true;
-  if (const Function *F = getCalledFunction())
-    return F->getParamAttributes(i).hasAttribute(Attributes::Nest);
-  return false;
-}
-
-bool CallInst::paramHasByValAttr(unsigned i) const {
-  if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::ByVal))
-    return true;
-  if (const Function *F = getCalledFunction())
-    return F->getParamAttributes(i).hasAttribute(Attributes::ByVal);
-  return false;
-}
-
-bool CallInst::paramHasNoAliasAttr(unsigned i) const {
-  if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::NoAlias))
-    return true;
-  if (const Function *F = getCalledFunction())
-    return F->getParamAttributes(i).hasAttribute(Attributes::NoAlias);
-  return false;
-}
-
-bool CallInst::paramHasNoCaptureAttr(unsigned i) const {
-  if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::NoCapture))
-    return true;
-  if (const Function *F = getCalledFunction())
-    return F->getParamAttributes(i).hasAttribute(Attributes::NoCapture);
   return false;
 }
 
@@ -720,67 +664,11 @@ bool InvokeInst::fnHasReturnsTwiceAttr() const {
   return false;
 }
 
-bool InvokeInst::paramHasSExtAttr(unsigned i) const {
+bool InvokeInst::paramHasAttr(unsigned i, Attributes::AttrVal A) const {
-  if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::SExt))
+  if (AttributeList.getParamAttributes(i).hasAttribute(A))
     return true;
   if (const Function *F = getCalledFunction())
-    return F->getParamAttributes(i).hasAttribute(Attributes::SExt);
+    return F->getParamAttributes(i).hasAttribute(A);
-  return false;
-}
-
-bool InvokeInst::paramHasZExtAttr(unsigned i) const {
-  if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::ZExt))
-    return true;
-  if (const Function *F = getCalledFunction())
-    return F->getParamAttributes(i).hasAttribute(Attributes::ZExt);
-  return false;
-}
-
-bool InvokeInst::paramHasInRegAttr(unsigned i) const {
-  if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::InReg))
-    return true;
-  if (const Function *F = getCalledFunction())
-    return F->getParamAttributes(i).hasAttribute(Attributes::InReg);
-  return false;
-}
-
-bool InvokeInst::paramHasStructRetAttr(unsigned i) const {
-  if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::StructRet))
-    return true;
-  if (const Function *F = getCalledFunction())
-    return F->getParamAttributes(i).hasAttribute(Attributes::StructRet);
-  return false;
-}
-
-bool InvokeInst::paramHasNestAttr(unsigned i) const {
-  if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::Nest))
-    return true;
-  if (const Function *F = getCalledFunction())
-    return F->getParamAttributes(i).hasAttribute(Attributes::Nest);
-  return false;
-}
-
-bool InvokeInst::paramHasByValAttr(unsigned i) const {
-  if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::ByVal))
-    return true;
-  if (const Function *F = getCalledFunction())
-    return F->getParamAttributes(i).hasAttribute(Attributes::ByVal);
-  return false;
-}
-
-bool InvokeInst::paramHasNoAliasAttr(unsigned i) const {
-  if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::NoAlias))
-    return true;
-  if (const Function *F = getCalledFunction())
-    return F->getParamAttributes(i).hasAttribute(Attributes::NoAlias);
-  return false;
-}
-
-bool InvokeInst::paramHasNoCaptureAttr(unsigned i) const {
-  if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::NoCapture))
-    return true;
-  if (const Function *F = getCalledFunction())
-    return F->getParamAttributes(i).hasAttribute(Attributes::NoCapture);
   return false;
 }