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

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165550 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/Attributes.h b/include/llvm/Attributes.h
index 2933defe96cb364b64868ba9442460a42c7e9429..1c2770995c20a0d1223e01c549ccaa547acb9695 100644 (file)
--- a/include/llvm/Attributes.h
+++ b/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.");

diff --git a/include/llvm/Instructions.h b/include/llvm/Instructions.h
index 597eca5aa46b40961e284f74d5de44b51f19f1e5..ea3aaae9c6f6b456245da0a06386701eb0229005 100644 (file)
--- a/include/llvm/Instructions.h
+++ b/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 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;
+  bool paramHasAttr(unsigned i, Attributes::AttrVal A) 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 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;
+  bool paramHasAttr(unsigned i, Attributes::AttrVal A) 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.

diff --git a/include/llvm/Support/CallSite.h b/include/llvm/Support/CallSite.h
index bbbec6d46c6aa3592349d9e2053dea4290a0a39f..c15326ee95fb217a7970c31107b392f5d617d334 100644 (file)
--- a/include/llvm/Support/CallSite.h
+++ b/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.
-  bool paramHasSExtAttr(unsigned i) const {
-    CALLSITE_DELEGATE_GETTER(paramHasSExtAttr(i));
-  }
-  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 Return true if the call or the callee has the given attribute.
+  bool paramHasAttr(unsigned i, Attributes::AttrVal A) const {
+    CALLSITE_DELEGATE_GETTER(paramHasAttr(i, A));
   }
 
   /// @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

diff --git a/include/llvm/Target/TargetLowering.h b/include/llvm/Target/TargetLowering.h
index 6f57e0a831c8a07de3cf229f83cafc01a8d333e6..b3149e960a8dba40b59228a2ebc6283e300e1d13 100644 (file)
--- a/include/llvm/Target/TargetLowering.h
+++ b/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)),
-      RetZExt(cs.paramHasZExtAttr(0)), IsVarArg(FTy->isVarArg()),
-      IsInReg(cs.paramHasInRegAttr(0)),
+    : Chain(chain), RetTy(retTy), RetSExt(cs.paramHasAttr(0, Attributes::SExt)),
+      RetZExt(cs.paramHasAttr(0, Attributes::ZExt)), IsVarArg(FTy->isVarArg()),
+      IsInReg(cs.paramHasAttr(0, Attributes::InReg)),
       DoesNotReturn(cs.doesNotReturn()),
       IsReturnValueUsed(!cs.getInstruction()->use_empty()),
       IsTailCall(isTailCall), NumFixedArgs(FTy->getNumParams()),

diff --git a/lib/Analysis/AliasAnalysis.cpp b/lib/Analysis/AliasAnalysis.cpp
index ec334a75a0e6745147e56bffd0bdb9499d1747f8..752edd52b454fb3d9e55a2f1c727b3834d77b6e2 100644 (file)
--- a/lib/Analysis/AliasAnalysis.cpp
+++ b/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;
 }
 

diff --git a/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp b/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
index c81db1e76fa6c5b3f21460d74d38bcd6e00d3563..dccc2fcf25bb58f1f9ead91bd4441e99c911f07c 100644 (file)
--- a/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
+++ b/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.isZExt  = CS.paramHasZExtAttr(attrInd);
-    Entry.isInReg = CS.paramHasInRegAttr(attrInd);
-    Entry.isSRet  = CS.paramHasStructRetAttr(attrInd);
-    Entry.isNest  = CS.paramHasNestAttr(attrInd);
-    Entry.isByVal = CS.paramHasByValAttr(attrInd);
+    Entry.isSExt  = CS.paramHasAttr(attrInd, Attributes::SExt);
+    Entry.isZExt  = CS.paramHasAttr(attrInd, Attributes::ZExt);
+    Entry.isInReg = CS.paramHasAttr(attrInd, Attributes::InReg);
+    Entry.isSRet  = CS.paramHasAttr(attrInd, Attributes::StructRet);
+    Entry.isNest  = CS.paramHasAttr(attrInd, Attributes::Nest);
+    Entry.isByVal = CS.paramHasAttr(attrInd, Attributes::ByVal);
     Entry.Alignment = CS.getParamAlignment(attrInd);
     Args.push_back(Entry);
   }

diff --git a/lib/Target/ARM/ARMFastISel.cpp b/lib/Target/ARM/ARMFastISel.cpp
index 405c2f441d12cac3b5b6f07f9a4768c90d5559fa..92248f53178f6fc8b819af92f6aae017cf7729de 100644 (file)
--- a/lib/Target/ARM/ARMFastISel.cpp
+++ b/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) ||
-        CS.paramHasStructRetAttr(AttrInd) ||
-        CS.paramHasNestAttr(AttrInd) ||
-        CS.paramHasByValAttr(AttrInd))
+    if (CS.paramHasAttr(AttrInd, Attributes::InReg) ||
+        CS.paramHasAttr(AttrInd, Attributes::StructRet) ||
+        CS.paramHasAttr(AttrInd, Attributes::Nest) ||
+        CS.paramHasAttr(AttrInd, Attributes::ByVal))
       return false;
 
     Type *ArgTy = (*i)->getType();

diff --git a/lib/Target/X86/X86FastISel.cpp b/lib/Target/X86/X86FastISel.cpp
index cf14fe05212afff6ed2bacc98ba27588d5050d87..dbae608352c2a0c044c62c027f9fea7be171d47c 100644 (file)
--- a/lib/Target/X86/X86FastISel.cpp
+++ b/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);
     }

diff --git a/lib/Transforms/IPO/FunctionAttrs.cpp b/lib/Transforms/IPO/FunctionAttrs.cpp
index 0e16589ececd4dd1cfe9ff6df3343365dc8a30f9..e0deb433112d8c78a26b3cfd8147e2d4250353a8 100644 (file)
--- a/lib/Transforms/IPO/FunctionAttrs.cpp
+++ b/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()))

diff --git a/lib/VMCore/Instructions.cpp b/lib/VMCore/Instructions.cpp
index f7bb4b264ed855ef393d6cd184fcd4ee69121ed2..0a097b8be201acfe4b4ae0a059fc9b1e4c5859c5 100644 (file)
--- a/lib/VMCore/Instructions.cpp
+++ b/lib/VMCore/Instructions.cpp
@@ -393,67 +393,11 @@ bool CallInst::fnHasReturnsTwiceAttr() const {
   return false;
 }
 
-bool CallInst::paramHasSExtAttr(unsigned i) const {
-  if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::SExt))
+bool CallInst::paramHasAttr(unsigned i, Attributes::AttrVal A) const {
+  if (AttributeList.getParamAttributes(i).hasAttribute(A))
     return true;
   if (const Function *F = getCalledFunction())
-    return F->getParamAttributes(i).hasAttribute(Attributes::SExt);
-  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 F->getParamAttributes(i).hasAttribute(A);
   return false;
 }
 
@@ -720,67 +664,11 @@ bool InvokeInst::fnHasReturnsTwiceAttr() const {
   return false;
 }
 
-bool InvokeInst::paramHasSExtAttr(unsigned i) const {
-  if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::SExt))
-    return true;
-  if (const Function *F = getCalledFunction())
-    return F->getParamAttributes(i).hasAttribute(Attributes::SExt);
-  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))
+bool InvokeInst::paramHasAttr(unsigned i, Attributes::AttrVal A) const {
+  if (AttributeList.getParamAttributes(i).hasAttribute(A))
     return true;
   if (const Function *F = getCalledFunction())
-    return F->getParamAttributes(i).hasAttribute(Attributes::NoCapture);
+    return F->getParamAttributes(i).hasAttribute(A);
   return false;
 }