X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FSlotCalculator.h;h=91006d70175cdf77eefa3b1cdc79ff3fd010916d;hb=87944916a4764dabc2f89cbec0a6c7e439c28530;hp=95282447a5fa1b90b5affdbfd6b72442f20f0a4f;hpb=697954c15da58bd8b186dbafdedd8b06db770201;p=oota-llvm.git

diff --git a/include/llvm/SlotCalculator.h b/include/llvm/SlotCalculator.h
index 95282447a5f..91006d70175 100644
--- a/include/llvm/SlotCalculator.h
+++ b/include/llvm/SlotCalculator.h
@@ -1,23 +1,24 @@
-//===-- llvm/Analysis/SlotCalculator.h - Calculate value slots ---*- C++ -*-==//
+//===-- llvm/SlotCalculator.h - Calculate value slots ------------*- C++ -*-==//
 //
-// This ModuleAnalyzer subclass calculates the slots that values will land in.
-// This is useful for when writing bytecode or assembly out, because you have 
-// to know these things.
+// This class calculates the slots that values will land in.  This is useful for
+// when writing bytecode or assembly out, because you have to know these things.
+//
+// Specifically, this class calculates the "type plane numbering" that you see
+// for a function if you strip out all of the symbols in it.  For assembly
+// writing, this is used when a symbol does not have a name.  For bytecode
+// writing, this is always used, and the symbol table is added on later.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_ANALYSIS_SLOTCALCULATOR_H
-#define LLVM_ANALYSIS_SLOTCALCULATOR_H
+#ifndef LLVM_SLOTCALCULATOR_H
+#define LLVM_SLOTCALCULATOR_H
 
-#include "llvm/SymTabValue.h"
 #include <vector>
 #include <map>
 class Value;
 class Module;
-class Method;
-class MethodArgument;
-class BasicBlock;
-class Instruction;
+class Function;
+class SymbolTable;
 
 class SlotCalculator {
   const Module *TheModule;
@@ -28,13 +29,14 @@ class SlotCalculator {
   std::map<const Value *, unsigned> NodeMap;
 
   // ModuleLevel - Used to keep track of which values belong to the module,
-  // and which values belong to the currently incorporated method.
+  // and which values belong to the currently incorporated function.
   //
   std::vector<unsigned> ModuleLevel;
 
 public:
   SlotCalculator(const Module *M, bool IgnoreNamed);
-  SlotCalculator(const Method *M, bool IgnoreNamed);// Start out in incorp state
+  // Start out in incorp state
+  SlotCalculator(const Function *M, bool IgnoreNamed);
   inline ~SlotCalculator() {}
   
   // getValSlot returns < 0 on error!
@@ -49,11 +51,11 @@ public:
     return Table[Plane]; 
   }
 
-  // If you'd like to deal with a method, use these two methods to get its data
-  // into the SlotCalculator!
+  // If you'd like to deal with a function, use these two methods to get its
+  // data into the SlotCalculator!
   //
-  void incorporateMethod(const Method *M);
-  void purgeMethod();
+  void incorporateFunction(const Function *F);
+  void purgeFunction();
 
 protected:
   // insertVal - Insert a value into the value table... Return the slot that it
@@ -70,7 +72,7 @@ protected:
   // doInsertVal - Small helper function to be called only be insertVal.
   int doInsertVal(const Value *D);
 
-  // processModule - Process all of the module level method declarations and
+  // processModule - Process all of the module level function declarations and
   // types that are available.
   //
   void processModule();