Large mechanical patch.

s/ParamAttr/Attribute/g
s/PAList/AttrList/g
s/FnAttributeWithIndex/AttributeWithIndex/g
s/FnAttr/Attribute/g

This sets the stage 
- to implement function notes as function attributes and 
- to distinguish between function attributes and return value attributes.

This requires corresponding changes in llvm-gcc and clang.



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

3 files changed, 26 insertions, 26 deletions

diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp
index baacbdd..4b0664e 100644
--- a/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -108,18 +108,18 @@ static void WriteStringRecord(unsigned Code, const std::string &Str,
 }
 
 // Emit information about parameter attributes.
-static void WriteParamAttrTable(const ValueEnumerator &VE, 
+static void WriteAttributeTable(const ValueEnumerator &VE, 
                                 BitstreamWriter &Stream) {
-  const std::vector<PAListPtr> &Attrs = VE.getParamAttrs();
+  const std::vector<AttrListPtr> &Attrs = VE.getAttributes();
   if (Attrs.empty()) return;
   
   Stream.EnterSubblock(bitc::PARAMATTR_BLOCK_ID, 3);
 
   SmallVector<uint64_t, 64> Record;
   for (unsigned i = 0, e = Attrs.size(); i != e; ++i) {
-    const PAListPtr &A = Attrs[i];
+    const AttrListPtr &A = Attrs[i];
     for (unsigned i = 0, e = A.getNumSlots(); i != e; ++i) {
-      const FnAttributeWithIndex &PAWI = A.getSlot(i);
+      const AttributeWithIndex &PAWI = A.getSlot(i);
       Record.push_back(PAWI.Index);
       Record.push_back(PAWI.Attrs);
     }
@@ -407,7 +407,7 @@ static void WriteModuleInfo(const Module *M, const ValueEnumerator &VE,
     Vals.push_back(F->getCallingConv());
     Vals.push_back(F->isDeclaration());
     Vals.push_back(getEncodedLinkage(F));
-    Vals.push_back(VE.getParamAttrID(F->getParamAttrs()));
+    Vals.push_back(VE.getAttributeID(F->getAttributes()));
     Vals.push_back(Log2_32(F->getAlignment())+1);
     Vals.push_back(F->hasSection() ? SectionMap[F->getSection()] : 0);
     Vals.push_back(getEncodedVisibility(F));
@@ -818,7 +818,7 @@ static void WriteInstruction(const Instruction &I, unsigned InstID,
     Code = bitc::FUNC_CODE_INST_INVOKE;
     
     const InvokeInst *II = cast<InvokeInst>(&I);
-    Vals.push_back(VE.getParamAttrID(II->getParamAttrs()));
+    Vals.push_back(VE.getAttributeID(II->getAttributes()));
     Vals.push_back(II->getCallingConv());
     Vals.push_back(VE.getValueID(I.getOperand(1)));      // normal dest
     Vals.push_back(VE.getValueID(I.getOperand(2)));      // unwind dest
@@ -892,7 +892,7 @@ static void WriteInstruction(const Instruction &I, unsigned InstID,
     Code = bitc::FUNC_CODE_INST_CALL;
     
     const CallInst *CI = cast<CallInst>(&I);
-    Vals.push_back(VE.getParamAttrID(CI->getParamAttrs()));
+    Vals.push_back(VE.getAttributeID(CI->getAttributes()));
     Vals.push_back((CI->getCallingConv() << 1) | unsigned(CI->isTailCall()));
     PushValueAndType(CI->getOperand(0), InstID, Vals, VE);  // Callee
     
@@ -1226,7 +1226,7 @@ static void WriteModule(const Module *M, BitstreamWriter &Stream) {
   WriteBlockInfo(VE, Stream);
   
   // Emit information about parameter attributes.
-  WriteParamAttrTable(VE, Stream);
+  WriteAttributeTable(VE, Stream);
   
   // Emit information describing all of the types in the module.
   WriteTypeTable(VE, Stream);
diff --git a/lib/Bitcode/Writer/ValueEnumerator.cpp b/lib/Bitcode/Writer/ValueEnumerator.cpp
index 21d0dfe..1c12bc4 100644
--- a/lib/Bitcode/Writer/ValueEnumerator.cpp
+++ b/lib/Bitcode/Writer/ValueEnumerator.cpp
@@ -47,7 +47,7 @@ ValueEnumerator::ValueEnumerator(const Module *M) {
   // Enumerate the functions.
   for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) {
     EnumerateValue(I);
-    EnumerateParamAttrs(cast<Function>(I)->getParamAttrs());
+    EnumerateAttributes(cast<Function>(I)->getAttributes());
   }
 
   // Enumerate the aliases.
@@ -90,9 +90,9 @@ ValueEnumerator::ValueEnumerator(const Module *M) {
           EnumerateOperandType(*OI);
         EnumerateType(I->getType());
         if (const CallInst *CI = dyn_cast<CallInst>(I))
-          EnumerateParamAttrs(CI->getParamAttrs());
+          EnumerateAttributes(CI->getAttributes());
         else if (const InvokeInst *II = dyn_cast<InvokeInst>(I))
-          EnumerateParamAttrs(II->getParamAttrs());
+          EnumerateAttributes(II->getAttributes());
       }
   }
   
@@ -247,14 +247,14 @@ void ValueEnumerator::EnumerateOperandType(const Value *V) {
   }
 }
 
-void ValueEnumerator::EnumerateParamAttrs(const PAListPtr &PAL) {
+void ValueEnumerator::EnumerateAttributes(const AttrListPtr &PAL) {
   if (PAL.isEmpty()) return;  // null is always 0.
   // Do a lookup.
-  unsigned &Entry = ParamAttrMap[PAL.getRawPointer()];
+  unsigned &Entry = AttributeMap[PAL.getRawPointer()];
   if (Entry == 0) {
     // Never saw this before, add it.
-    ParamAttrs.push_back(PAL);
-    Entry = ParamAttrs.size();
+    Attributes.push_back(PAL);
+    Entry = Attributes.size();
   }
 }
 
@@ -303,7 +303,7 @@ void ValueEnumerator::incorporateFunction(const Function &F) {
   
   // Add the function's parameter attributes so they are available for use in
   // the function's instruction.
-  EnumerateParamAttrs(F.getParamAttrs());
+  EnumerateAttributes(F.getAttributes());
 
   FirstInstID = Values.size();
   
diff --git a/lib/Bitcode/Writer/ValueEnumerator.h b/lib/Bitcode/Writer/ValueEnumerator.h
index 405aec7..bb0324b 100644
--- a/lib/Bitcode/Writer/ValueEnumerator.h
+++ b/lib/Bitcode/Writer/ValueEnumerator.h
@@ -25,7 +25,7 @@ class Value;
 class BasicBlock;
 class Function;
 class Module;
-class PAListPtr;
+class AttrListPtr;
 class TypeSymbolTable;
 class ValueSymbolTable;
 
@@ -45,9 +45,9 @@ private:
   ValueMapType ValueMap;
   ValueList Values;
   
-  typedef DenseMap<void*, unsigned> ParamAttrMapType;
-  ParamAttrMapType ParamAttrMap;
-  std::vector<PAListPtr> ParamAttrs;
+  typedef DenseMap<void*, unsigned> AttributeMapType;
+  AttributeMapType AttributeMap;
+  std::vector<AttrListPtr> Attributes;
   
   /// BasicBlocks - This contains all the basic blocks for the currently
   /// incorporated function.  Their reverse mapping is stored in ValueMap.
@@ -76,10 +76,10 @@ public:
     return I->second-1;
   }
   
-  unsigned getParamAttrID(const PAListPtr &PAL) const {
+  unsigned getAttributeID(const AttrListPtr &PAL) const {
     if (PAL.isEmpty()) return 0;  // Null maps to zero.
-    ParamAttrMapType::const_iterator I = ParamAttrMap.find(PAL.getRawPointer());
-    assert(I != ParamAttrMap.end() && "ParamAttr not in ValueEnumerator!");
+    AttributeMapType::const_iterator I = AttributeMap.find(PAL.getRawPointer());
+    assert(I != AttributeMap.end() && "Attribute not in ValueEnumerator!");
     return I->second;
   }
 
@@ -95,8 +95,8 @@ public:
   const std::vector<const BasicBlock*> &getBasicBlocks() const {
     return BasicBlocks; 
   }
-  const std::vector<PAListPtr> &getParamAttrs() const {
-    return ParamAttrs;
+  const std::vector<AttrListPtr> &getAttributes() const {
+    return Attributes;
   }
 
   /// PurgeAggregateValues - If there are any aggregate values at the end of the
@@ -116,7 +116,7 @@ private:
   void EnumerateValue(const Value *V);
   void EnumerateType(const Type *T);
   void EnumerateOperandType(const Value *V);
-  void EnumerateParamAttrs(const PAListPtr &PAL);
+  void EnumerateAttributes(const AttrListPtr &PAL);
   
   void EnumerateTypeSymbolTable(const TypeSymbolTable &ST);
   void EnumerateValueSymbolTable(const ValueSymbolTable &ST);