change Target.getInstructionsByEnumValue to return a reference

to a vector that CGT stores instead of synthesizing it on every 
call.

llvm-svn: 98910

llvm/utils/TableGen/AsmMatcherEmitter.cpp

@@ -845,8 +845,8 @@ void AsmMatcherInfo::BuildInfo(CodeGenTarget &Target) {
   // singleton register classes.
   std::set<std::string> SingletonRegisterNames;
   
-  std::vector<const CodeGenInstruction*> InstrList;
+  const std::vector<const CodeGenInstruction*> &InstrList =
-  Target.getInstructionsByEnumValue(InstrList);
+    Target.getInstructionsByEnumValue();
   
   for (unsigned i = 0, e = InstrList.size(); i != e; ++i) {
     const CodeGenInstruction &CGI = *InstrList[i];

llvm/utils/TableGen/AsmWriterEmitter.cpp

@@ -263,7 +263,7 @@ void AsmWriterEmitter::EmitPrintInstruction(raw_ostream &O) {
                       AsmWriter->getValueAsInt("OperandSpacing")));
 
   // Get the instruction numbering.
-  Target.getInstructionsByEnumValue(NumberedInstructions);
+  NumberedInstructions = Target.getInstructionsByEnumValue();
   
   // Compute the CodeGenInstruction -> AsmWriterInst mapping.  Note that not
   // all machine instructions are necessarily being printed, so there may be
@@ -499,8 +499,8 @@ void AsmWriterEmitter::EmitGetInstructionName(raw_ostream &O) {
   Record *AsmWriter = Target.getAsmWriter();
   std::string ClassName = AsmWriter->getValueAsString("AsmWriterClassName");
 
-  std::vector<const CodeGenInstruction*> NumberedInstructions;
+  const std::vector<const CodeGenInstruction*> &NumberedInstructions =
-  Target.getInstructionsByEnumValue(NumberedInstructions);
+    Target.getInstructionsByEnumValue();
   
   StringToOffsetTable StringTable;
   O <<

llvm/utils/TableGen/CodeEmitterGen.cpp

@@ -86,8 +86,8 @@ void CodeEmitterGen::run(raw_ostream &o) {
   EmitSourceFileHeader("Machine Code Emitter", o);
   std::string Namespace = Insts[0]->getValueAsString("Namespace") + "::";
   
-  std::vector<const CodeGenInstruction*> NumberedInstructions;
+  const std::vector<const CodeGenInstruction*> &NumberedInstructions =
-  Target.getInstructionsByEnumValue(NumberedInstructions);
+    Target.getInstructionsByEnumValue();
 
   // Emit function declaration
   o << "unsigned " << Target.getName() << "CodeEmitter::"
@@ -95,7 +95,7 @@ void CodeEmitterGen::run(raw_ostream &o) {
 
   // Emit instruction base values
   o << "  static const unsigned InstBits[] = {\n";
-  for (std::vector<const CodeGenInstruction*>::iterator
+  for (std::vector<const CodeGenInstruction*>::const_iterator
           IN = NumberedInstructions.begin(),
           EN = NumberedInstructions.end();
        IN != EN; ++IN) {

llvm/utils/TableGen/CodeGenDAGPatterns.cpp

@@ -2362,8 +2362,8 @@ void CodeGenDAGPatterns::AddPatternToMatch(const TreePattern *Pattern,
 
 
 void CodeGenDAGPatterns::InferInstructionFlags() {
-  std::vector<const CodeGenInstruction*> Instructions;
+  const std::vector<const CodeGenInstruction*> &Instructions =
-  Target.getInstructionsByEnumValue(Instructions);
+    Target.getInstructionsByEnumValue();
   for (unsigned i = 0, e = Instructions.size(); i != e; ++i) {
     CodeGenInstruction &InstInfo =
       const_cast<CodeGenInstruction &>(*Instructions[i]);

llvm/utils/TableGen/CodeGenTarget.cpp

@@ -300,11 +300,8 @@ GetInstByName(const char *Name,
 
 /// getInstructionsByEnumValue - Return all of the instructions defined by the
 /// target, ordered by their enum value.
-void CodeGenTarget::
+void CodeGenTarget::ComputeInstrsByEnum() {
-getInstructionsByEnumValue(std::vector<const CodeGenInstruction*>
-                                                 &NumberedInstructions) {
   const std::map<std::string, CodeGenInstruction> &Insts = getInstructions();
-  
   const CodeGenInstruction *PHI = GetInstByName("PHI", Insts);
   const CodeGenInstruction *INLINEASM = GetInstByName("INLINEASM", Insts);
   const CodeGenInstruction *DBG_LABEL = GetInstByName("DBG_LABEL", Insts);
@@ -323,18 +320,18 @@ getInstructionsByEnumValue(std::vector<const CodeGenInstruction*>
   const CodeGenInstruction *DBG_VALUE = GetInstByName("DBG_VALUE", Insts);
 
   // Print out the rest of the instructions now.
-  NumberedInstructions.push_back(PHI);
+  InstrsByEnum.push_back(PHI);
-  NumberedInstructions.push_back(INLINEASM);
+  InstrsByEnum.push_back(INLINEASM);
-  NumberedInstructions.push_back(DBG_LABEL);
+  InstrsByEnum.push_back(DBG_LABEL);
-  NumberedInstructions.push_back(EH_LABEL);
+  InstrsByEnum.push_back(EH_LABEL);
-  NumberedInstructions.push_back(GC_LABEL);
+  InstrsByEnum.push_back(GC_LABEL);
-  NumberedInstructions.push_back(KILL);
+  InstrsByEnum.push_back(KILL);
-  NumberedInstructions.push_back(EXTRACT_SUBREG);
+  InstrsByEnum.push_back(EXTRACT_SUBREG);
-  NumberedInstructions.push_back(INSERT_SUBREG);
+  InstrsByEnum.push_back(INSERT_SUBREG);
-  NumberedInstructions.push_back(IMPLICIT_DEF);
+  InstrsByEnum.push_back(IMPLICIT_DEF);
-  NumberedInstructions.push_back(SUBREG_TO_REG);
+  InstrsByEnum.push_back(SUBREG_TO_REG);
-  NumberedInstructions.push_back(COPY_TO_REGCLASS);
+  InstrsByEnum.push_back(COPY_TO_REGCLASS);
-  NumberedInstructions.push_back(DBG_VALUE);
+  InstrsByEnum.push_back(DBG_VALUE);
   for (inst_iterator II = inst_begin(), E = inst_end(); II != E; ++II)
     if (&II->second != PHI &&
         &II->second != INLINEASM &&
@@ -348,7 +345,7 @@ getInstructionsByEnumValue(std::vector<const CodeGenInstruction*>
         &II->second != SUBREG_TO_REG &&
         &II->second != COPY_TO_REGCLASS &&
         &II->second != DBG_VALUE)
-      NumberedInstructions.push_back(&II->second);
+      InstrsByEnum.push_back(&II->second);
 }
 
 

llvm/utils/TableGen/CodeGenTarget.h

@@ -70,6 +70,8 @@ class CodeGenTarget {
   void ReadRegisterClasses() const;
   void ReadInstructions() const;
   void ReadLegalValueTypes() const;
+  
+  std::vector<const CodeGenInstruction*> InstrsByEnum;
 public:
   CodeGenTarget();
 
@@ -210,13 +212,18 @@ public:
 
   /// getInstructionsByEnumValue - Return all of the instructions defined by the
   /// target, ordered by their enum value.
-  void getInstructionsByEnumValue(std::vector<const CodeGenInstruction*>
+  const std::vector<const CodeGenInstruction*> &getInstructionsByEnumValue() {
-                                                &NumberedInstructions);
+    if (InstrsByEnum.empty()) ComputeInstrsByEnum();
+    return InstrsByEnum;
+  }
 
 
   /// isLittleEndianEncoding - are instruction bit patterns defined as  [0..n]?
   ///
   bool isLittleEndianEncoding() const;
+  
+private:
+  void ComputeInstrsByEnum();
 };
 
 /// ComplexPattern - ComplexPattern info, corresponding to the ComplexPattern

llvm/utils/TableGen/DisassemblerEmitter.cpp

@@ -108,8 +108,8 @@ void DisassemblerEmitter::run(raw_ostream &OS) {
   if (Target.getName() == "X86") {
     DisassemblerTables Tables;
   
-    std::vector<const CodeGenInstruction*> numberedInstructions;
+    const std::vector<const CodeGenInstruction*> &numberedInstructions =
-    Target.getInstructionsByEnumValue(numberedInstructions);
+      Target.getInstructionsByEnumValue();
     
     for (unsigned i = 0, e = numberedInstructions.size(); i != e; ++i)
       RecognizableInstr::processInstr(Tables, *numberedInstructions[i], i);

llvm/utils/TableGen/EDEmitter.cpp

@@ -549,8 +549,8 @@ static void X86ExtractSemantics(FlagsConstantEmitter &instFlags,
 /// @arg target     - The CodeGenTarget to use as a source of instructions
 static void populateInstInfo(CompoundConstantEmitter &infoArray,
                              CodeGenTarget &target) {
-  std::vector<const CodeGenInstruction*> numberedInstructions;
+  const std::vector<const CodeGenInstruction*> &numberedInstructions =
-  target.getInstructionsByEnumValue(numberedInstructions);
+    target.getInstructionsByEnumValue();
   
   unsigned int index;
   unsigned int numInstructions = numberedInstructions.size();

llvm/utils/TableGen/InstrEnumEmitter.cpp

@@ -40,8 +40,8 @@ void InstrEnumEmitter::run(raw_ostream &OS) {
     exit(1);
   }
 
-  std::vector<const CodeGenInstruction*> NumberedInstructions;
+  const std::vector<const CodeGenInstruction*> &NumberedInstructions =
-  Target.getInstructionsByEnumValue(NumberedInstructions);
+    Target.getInstructionsByEnumValue();
 
   OS << "namespace " << Namespace << " {\n";
   OS << "  enum {\n";

llvm/utils/TableGen/InstrInfoEmitter.cpp

@@ -244,8 +244,8 @@ void InstrInfoEmitter::run(raw_ostream &OS) {
   //
   OS << "\nstatic const TargetInstrDesc " << TargetName
      << "Insts[] = {\n";
-  std::vector<const CodeGenInstruction*> NumberedInstructions;
+  const std::vector<const CodeGenInstruction*> &NumberedInstructions =
-  Target.getInstructionsByEnumValue(NumberedInstructions);
+    Target.getInstructionsByEnumValue();
 
   for (unsigned i = 0, e = NumberedInstructions.size(); i != e; ++i)
     emitRecord(*NumberedInstructions[i], i, InstrInfo, EmittedLists,