Added LLVM copyright header (for lack of a better term).

[oota-llvm.git] / include / llvm / SlotCalculator.h

diff --git a/include/llvm/SlotCalculator.h b/include/llvm/SlotCalculator.h
index c7b3149054c3efabe7e268ecf13846ea50c670dd..7e56de99dca72207fa1b2f60e6117cd6e8ac0c61 100644 (file)
--- a/include/llvm/SlotCalculator.h
+++ b/include/llvm/SlotCalculator.h
@@ -1,44 +1,53 @@
-//===-- llvm/Analysis/SlotCalculator.h - Calculate value slots ---*- C++ -*-==//
+//===-- llvm/SlotCalculator.h - Calculate value slots -----------*- C++ -*-===//
+// 
+//                     The LLVM Compiler Infrastructure
 //
-// 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 file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// 
+//===----------------------------------------------------------------------===//
+//
+// 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;
   bool IgnoreNamedNodes;     // Shall we not count named nodes?
 
-  typedef vector<const Value*> TypePlane;
-  vector<TypePlane> Table;
-  map<const Value *, unsigned> NodeMap;
+  typedef std::vector<const Value*> TypePlane;
+  std::vector<TypePlane> Table;
+  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.
   //
-  vector<unsigned> ModuleLevel;
+  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!
-  int getValSlot(const Value *D) const;
+  // getSlot returns < 0 on error!
+  int getSlot(const Value *D) const;
 
   inline unsigned getNumPlanes() const { return Table.size(); }
   inline unsigned getModuleLevel(unsigned Plane) const { 
@@ -49,28 +58,29 @@ 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
-  // occupies, or -1 if the declaration is to be ignored because of the
-  // IgnoreNamedNodes flag.
+  // getOrCreateSlot - Values can be crammed into here at will... if
+  // they haven't been inserted already, they get inserted, otherwise
+  // they are ignored.
   //
-  int insertVal(const Value *D, bool dontIgnore = false);
+  int getOrCreateSlot(const Value *D);
 
-  // insertValue - Values can be crammed into here at will... if they haven't
-  // been inserted already, they get inserted, otherwise they are ignored.
+  // insertValue - Insert a value into the value table... Return the
+  // slot that it occupies, or -1 if the declaration is to be ignored
+  // because of the IgnoreNamedNodes flag.
   //
-  int insertValue(const Value *D);
+  int insertValue(const Value *D, bool dontIgnore = false);
 
-  // doInsertVal - Small helper function to be called only be insertVal.
-  int doInsertVal(const Value *D);
+  // doInsertValue - Small helper function to be called only be insertVal.
+  int doInsertValue(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();