Move FunctionArgument out of iOther.h into Argument.h and rename class to

be 'Argument' instead of FunctionArgument.


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

lib/Analysis/DataStructure/FunctionRepBuilder.cpp

@@ -143,26 +143,28 @@ void FunctionRepBuilder::initializeWorkList(Function *Func) {
   // the worklists...
   //
   for (Function::ArgumentListType::iterator I = Func->getArgumentList().begin(),
-         E = Func->getArgumentList().end(); I != E; ++I)
+         E = Func->getArgumentList().end(); I != E; ++I) {
+    Value *Arg = (Value*)(*I);
     // Only process arguments that are of pointer type...
-    if (PointerType *PT = dyn_cast<PointerType>((*I)->getType())) {
-      ArgDSNode *Arg = new ArgDSNode(*I);
-      ArgNodes.push_back(Arg);
+    if (PointerType *PT = dyn_cast<PointerType>(Arg->getType())) {
+      ArgDSNode *ArgNode = new ArgDSNode(*I);
+      ArgNodes.push_back(ArgNode);
       
       // Add a critical shadow value for it to represent what it is pointing
       // to and add this to the value map...
       ShadowDSNode *Shad = new ShadowDSNode(PT->getElementType(),
                                             Func->getParent(), true);
       ShadowNodes.push_back(Shad);
-      ValueMap[*I].add(PointerVal(Shad), *I);
+      ValueMap[Arg].add(PointerVal(Shad), Arg);
       
       // The value of the argument is the shadow value...
-      Arg->getLink(0).add(Shad);
+      ArgNode->getLink(0).add(Shad);
       
       // Make sure that all users of the argument are processed...
-      addAllUsesToWorkList(*I);
+      addAllUsesToWorkList(Arg);
     }
-  
+  }
+
   // Iterate over the instructions in the method.  Create nodes for malloc and
   // call instructions.  Add all uses of these to the worklist of instructions
   // to process.

lib/Analysis/DataStructure/NodeImpl.cpp

@@ -11,6 +11,7 @@
 #include "llvm/BasicBlock.h"
 #include "llvm/iMemory.h"
 #include "llvm/iOther.h"
+#include "llvm/Argument.h"
 #include "Support/STLExtras.h"
 #include <algorithm>
 #include <sstream>
@@ -288,7 +289,7 @@ void CallDSNode::mapNode(map<const DSNode*, DSNode*> &NodeMap,
     MapPVS(ArgLinks[i], Old->ArgLinks[i], NodeMap);
 }
 
-ArgDSNode::ArgDSNode(FunctionArgument *FA)
+ArgDSNode::ArgDSNode(Argument *FA)
   : DSNode(ArgNode, FA->getType()), FuncArg(FA) {
 }
 

lib/Analysis/Expressions.cpp

@@ -245,7 +245,7 @@ ExprType analysis::ClassifyExpression(Value *Expr) {
     std::cerr << "Bizarre thing to expr classify: " << Expr << "\n";
     return Expr;
   case Value::GlobalVariableVal:        // Global Variable & Function argument:
-  case Value::FunctionArgumentVal:      // nothing known, return variable itself
+  case Value::ArgumentVal:              // nothing known, return variable itself
     return Expr;
   case Value::ConstantVal:              // Constant value, just return constant
     Constant *CPV = cast<Constant>(Expr);

lib/Analysis/InductionVariable.cpp

@@ -28,7 +28,7 @@ using analysis::ExprType;
 
 
 static bool isLoopInvariant(const Value *V, const cfg::Loop *L) {
-  if (isa<Constant>(V) || isa<FunctionArgument>(V) || isa<GlobalValue>(V))
+  if (isa<Constant>(V) || isa<Argument>(V) || isa<GlobalValue>(V))
     return true;
   
   const Instruction *I = cast<Instruction>(V);

lib/Bytecode/Reader/Reader.cpp

@@ -19,6 +19,7 @@
 #include "llvm/ConstantVals.h"
 #include "llvm/iPHINode.h"
 #include "llvm/iOther.h"
+#include "llvm/Argument.h"
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/mman.h>
@@ -280,7 +281,7 @@ bool BytecodeParser::ParseMethod(const uchar *&Buf, const uchar *EndBuf,
   const FunctionType::ParamTypes &Params = MTy->getParamTypes();
   for (FunctionType::ParamTypes::const_iterator It = Params.begin();
        It != Params.end(); ++It) {
-    FunctionArgument *FA = new FunctionArgument(*It);
+    Argument *FA = new Argument(*It);
     if (insertValue(FA, Values) == -1) {
       Error = "Error reading method arguments!\n";
       delete M; return failure(true); 

lib/Bytecode/Writer/SlotCalculator.cpp

@@ -19,6 +19,7 @@
 #include "llvm/iOther.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/SymbolTable.h"
+#include "llvm/Argument.h"
 #include "Support/DepthFirstIterator.h"
 #include "Support/STLExtras.h"
 #include <algorithm>

lib/Bytecode/Writer/Writer.cpp

@@ -73,7 +73,7 @@ void BytecodeWriter::outputConstants(bool isFunction) {
       ValNo = Type::FirstDerivedTyID; // Start emitting at the derived types...
     
     // Scan through and ignore function arguments...
-    for (; ValNo < Plane.size() && isa<FunctionArgument>(Plane[ValNo]); ValNo++)
+    for (; ValNo < Plane.size() && isa<Argument>(Plane[ValNo]); ValNo++)
       /*empty*/;
 
     unsigned NC = ValNo;              // Number of constants

lib/CodeGen/InstrSelection/InstrForest.cpp

@@ -298,7 +298,7 @@ InstrForest::buildTreeForInstruction(Instruction *instr)
 	&& !instr->isTerminator();
     
       if (includeAddressOperand || isa<Instruction>(operand) ||
-	  isa<Constant>(operand) || isa<FunctionArgument>(operand) ||
+	  isa<Constant>(operand) || isa<Argument>(operand) ||
 	  isa<GlobalVariable>(operand))
 	{
 	  // This operand is a data value

lib/Linker/LinkModules.cpp

@@ -18,6 +18,7 @@
 #include "llvm/DerivedTypes.h"
 #include "llvm/iOther.h"
 #include "llvm/ConstantVals.h"
+#include "llvm/Argument.h"
 #include <iostream>
 using std::cerr;
 using std::string;
@@ -301,10 +302,10 @@ static bool LinkFunctionBody(Function *Dest, const Function *Src,
   for (Function::ArgumentListType::const_iterator 
          I = Src->getArgumentList().begin(),
          E = Src->getArgumentList().end(); I != E; ++I) {
-    const FunctionArgument *SMA = *I;
+    const Argument *SMA = *I;
 
     // Create the new method argument and add to the dest method...
-    FunctionArgument *DMA = new FunctionArgument(SMA->getType(),SMA->getName());
+    Argument *DMA = new Argument(SMA->getType(), SMA->getName());
     Dest->getArgumentList().push_back(DMA);
 
     // Add a mapping to our local map

lib/Target/SparcV9/InstrSelection/InstrForest.cpp

@@ -298,7 +298,7 @@ InstrForest::buildTreeForInstruction(Instruction *instr)
 	&& !instr->isTerminator();
     
       if (includeAddressOperand || isa<Instruction>(operand) ||
-	  isa<Constant>(operand) || isa<FunctionArgument>(operand) ||
+	  isa<Constant>(operand) || isa<Argument>(operand) ||
 	  isa<GlobalVariable>(operand))
 	{
 	  // This operand is a data value

lib/Transforms/IPO/InlineSimple.cpp

@@ -23,6 +23,7 @@
 #include "llvm/iPHINode.h"
 #include "llvm/iOther.h"
 #include "llvm/Type.h"
+#include "llvm/Argument.h"
 #include <algorithm>
 #include <map>
 #include <iostream>

lib/Transforms/IPO/MutateStructTypes.cpp

@@ -22,6 +22,7 @@
 #include "llvm/iMemory.h"
 #include "llvm/iTerminators.h"
 #include "llvm/iOther.h"
+#include "llvm/Argument.h"
 #include "Support/STLExtras.h"
 #include <algorithm>
 using std::map;
@@ -337,9 +338,8 @@ void MutateStructTypes::transformMethod(Function *m) {
 
   // Okay, first order of business, create the arguments...
   for (unsigned i = 0, e = M->getArgumentList().size(); i != e; ++i) {
-    const FunctionArgument *OFA = M->getArgumentList()[i];
-    FunctionArgument *NFA = new FunctionArgument(ConvertType(OFA->getType()),
-                                                 OFA->getName());
+    const Argument *OFA = M->getArgumentList()[i];
+    Argument *NFA = new Argument(ConvertType(OFA->getType()), OFA->getName());
     NewMeth->getArgumentList().push_back(NFA);
     LocalValueMap[OFA] = NFA; // Keep track of value mapping
   }

lib/Transforms/IPO/OldPoolAllocate.cpp

@@ -20,6 +20,7 @@
 #include "llvm/ConstantVals.h"
 #include "llvm/Target/TargetData.h"
 #include "llvm/Support/InstVisitor.h"
+#include "llvm/Argument.h"
 #include "Support/DepthFirstIterator.h"
 #include "Support/STLExtras.h"
 #include <algorithm>
@@ -677,8 +678,8 @@ void PoolAllocate::transformFunction(TransformFunctionInfo &TFI,
   // Add arguments to the function... starting with all of the old arguments
   vector<Value*> ArgMap;
   for (unsigned i = 0, e = TFI.Func->getArgumentList().size(); i != e; ++i) {
-    const FunctionArgument *OFA = TFI.Func->getArgumentList()[i];
-    FunctionArgument *NFA = new FunctionArgument(OFA->getType(),OFA->getName());
+    const Argument *OFA = TFI.Func->getArgumentList()[i];
+    Argument *NFA = new Argument(OFA->getType(), OFA->getName());
     NewFunc->getArgumentList().push_back(NFA);
     ArgMap.push_back(NFA);  // Keep track of the arguments 
   }
@@ -690,7 +691,7 @@ void PoolAllocate::transformFunction(TransformFunctionInfo &TFI,
       Name = "retpool";
     else
       Name = ArgMap[TFI.ArgInfo[i].ArgNo]->getName();  // Get the arg name
-    FunctionArgument *NFA = new FunctionArgument(PoolTy, Name+".pool");
+    Argument *NFA = new Argument(PoolTy, Name+".pool");
     NewFunc->getArgumentList().push_back(NFA);
   }
 

lib/Transforms/Instrumentation/TraceValues.cpp

@@ -257,7 +257,7 @@ static inline void InsertCodeToShowFunctionEntry(Function *M, Function *Printf){
   unsigned ArgNo = 0;
   for (Function::ArgumentListType::const_iterator
          I = argList.begin(), E = argList.end(); I != E; ++I, ++ArgNo) {
-    InsertVerbosePrintInst(*I, BB, BBI,
+    InsertVerbosePrintInst((Value*)*I, BB, BBI,
                            "  Arg #" + utostr(ArgNo), Printf);
   }
 }

lib/Transforms/Scalar/InductionVars.cpp

@@ -37,7 +37,7 @@ using std::cerr;
 // an interval invariant computation.
 //
 static bool isLoopInvariant(cfg::Interval *Int, Value *V) {
-  assert(isa<Constant>(V) || isa<Instruction>(V) || isa<FunctionArgument>(V));
+  assert(isa<Constant>(V) || isa<Instruction>(V) || isa<Argument>(V));
 
   if (!isa<Instruction>(V))
     return true;  // Constants and arguments are always loop invariant

lib/Transforms/Scalar/SCCP.cpp

@@ -140,7 +140,7 @@ private:
 
   // getValueState - Return the InstVal object that corresponds to the value.
   // This function is neccesary because not all values should start out in the
-  // underdefined state... FunctionArgument's should be overdefined, and
+  // underdefined state... Argument's should be overdefined, and
   // constants should be marked as constants.  If a value is not known to be an
   // Instruction object, then use this accessor to get its value from the map.
   //
@@ -150,7 +150,7 @@ private:
       
     if (Constant *CPV = dyn_cast<Constant>(V)) {  // Constants are constant
       ValueState[CPV].markConstant(CPV);
-    } else if (isa<FunctionArgument>(V)) {        // FuncArgs are overdefined
+    } else if (isa<Argument>(V)) {                // Arguments are overdefined
       ValueState[V].markOverdefined();
     } 
     // All others are underdefined by default...

lib/Transforms/Utils/Linker.cpp

@@ -18,6 +18,7 @@
 #include "llvm/DerivedTypes.h"
 #include "llvm/iOther.h"
 #include "llvm/ConstantVals.h"
+#include "llvm/Argument.h"
 #include <iostream>
 using std::cerr;
 using std::string;
@@ -301,10 +302,10 @@ static bool LinkFunctionBody(Function *Dest, const Function *Src,
   for (Function::ArgumentListType::const_iterator 
          I = Src->getArgumentList().begin(),
          E = Src->getArgumentList().end(); I != E; ++I) {
-    const FunctionArgument *SMA = *I;
+    const Argument *SMA = *I;
 
     // Create the new method argument and add to the dest method...
-    FunctionArgument *DMA = new FunctionArgument(SMA->getType(),SMA->getName());
+    Argument *DMA = new Argument(SMA->getType(), SMA->getName());
     Dest->getArgumentList().push_back(DMA);
 
     // Add a mapping to our local map

lib/VMCore/AsmWriter.cpp

@@ -20,6 +20,7 @@
 #include "llvm/iPHINode.h"
 #include "llvm/iOther.h"
 #include "llvm/SymbolTable.h"
+#include "llvm/Argument.h"
 #include "Support/StringExtras.h"
 #include "Support/STLExtras.h"
 #include <algorithm>
@@ -30,7 +31,7 @@ using std::vector;
 using std::ostream;
 
 static const Module *getModuleFromVal(const Value *V) {
-  if (const FunctionArgument *MA = dyn_cast<const FunctionArgument>(V))
+  if (const Argument *MA = dyn_cast<const Argument>(V))
     return MA->getParent() ? MA->getParent()->getParent() : 0;
   else if (const BasicBlock *BB = dyn_cast<const BasicBlock>(V))
     return BB->getParent() ? BB->getParent()->getParent() : 0;
@@ -46,7 +47,7 @@ static const Module *getModuleFromVal(const Value *V) {
 
 static SlotCalculator *createSlotCalculator(const Value *V) {
   assert(!isa<Type>(V) && "Can't create an SC for a type!");
-  if (const FunctionArgument *FA = dyn_cast<const FunctionArgument>(V)) {
+  if (const Argument *FA = dyn_cast<const Argument>(V)) {
     return new SlotCalculator(FA->getParent(), true);
   } else if (const Instruction *I = dyn_cast<const Instruction>(V)) {
     return new SlotCalculator(I->getParent()->getParent(), true);
@@ -286,7 +287,7 @@ private :
   void printConstant(const Constant *CPV);
   void printGlobal(const GlobalVariable *GV);
   void printFunction(const Function *F);
-  void printFunctionArgument(const FunctionArgument *FA);
+  void printArgument(const Argument *FA);
   void printBasicBlock(const BasicBlock *BB);
   void printInstruction(const Instruction *I);
   ostream &printType(const Type *Ty);
@@ -397,7 +398,7 @@ void AssemblyWriter::printFunction(const Function *M) {
 
   if (!M->isExternal()) {
     for_each(M->getArgumentList().begin(), M->getArgumentList().end(),
-	     bind_obj(this, &AssemblyWriter::printFunctionArgument));
+	     bind_obj(this, &AssemblyWriter::printArgument));
   } else {
     // Loop over the arguments, printing them...
     const FunctionType *MT = M->getFunctionType();
@@ -432,10 +433,10 @@ void AssemblyWriter::printFunction(const Function *M) {
   Table.purgeFunction();
 }
 
-// printFunctionArgument - This member is called for every argument that 
+// printArgument - This member is called for every argument that 
 // is passed into the function.  Simply print it out
 //
-void AssemblyWriter::printFunctionArgument(const FunctionArgument *Arg) {
+void AssemblyWriter::printArgument(const Argument *Arg) {
   // Insert commas as we go... the first arg doesn't get a comma
   if (Arg != Arg->getParent()->getArgumentList().front()) Out << ", ";
 
@@ -679,7 +680,7 @@ void Type::print(std::ostream &o) const {
     o << getDescription();
 }
 
-void FunctionArgument::print(std::ostream &o) const {
+void Argument::print(std::ostream &o) const {
   o << getType() << " " << getName();
 }
 
@@ -710,7 +711,7 @@ CachedWriter &CachedWriter::operator<<(const Value *V) {
   case Value::ConstantVal:
     Out << " "; AW->write(V->getType());
     Out << " " << cast<Constant>(V)->getStrValue(); break;
-  case Value::FunctionArgumentVal: 
+  case Value::ArgumentVal: 
     AW->write(V->getType()); Out << " " << V->getName(); break;
   case Value::TypeVal:           AW->write(cast<const Type>(V)); break;
   case Value::InstructionVal:    AW->write(cast<Instruction>(V)); break;

lib/VMCore/Linker.cpp

@@ -18,6 +18,7 @@
 #include "llvm/DerivedTypes.h"
 #include "llvm/iOther.h"
 #include "llvm/ConstantVals.h"
+#include "llvm/Argument.h"
 #include <iostream>
 using std::cerr;
 using std::string;
@@ -301,10 +302,10 @@ static bool LinkFunctionBody(Function *Dest, const Function *Src,
   for (Function::ArgumentListType::const_iterator 
          I = Src->getArgumentList().begin(),
          E = Src->getArgumentList().end(); I != E; ++I) {
-    const FunctionArgument *SMA = *I;
+    const Argument *SMA = *I;
 
     // Create the new method argument and add to the dest method...
-    FunctionArgument *DMA = new FunctionArgument(SMA->getType(),SMA->getName());
+    Argument *DMA = new Argument(SMA->getType(), SMA->getName());
     Dest->getArgumentList().push_back(DMA);
 
     // Add a mapping to our local map

lib/VMCore/SlotCalculator.cpp

@@ -19,6 +19,7 @@
 #include "llvm/iOther.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/SymbolTable.h"
+#include "llvm/Argument.h"
 #include "Support/DepthFirstIterator.h"
 #include "Support/STLExtras.h"
 #include <algorithm>