From 8faf8d93d560e4f75a4fc30a4c1943e23c0fcae3 Mon Sep 17 00:00:00 2001 From: Alkis Evlogimenos Date: Fri, 17 Oct 2003 02:02:40 +0000 Subject: [PATCH] Eliminate some extraneous code in SlotCalculator::insertVal(). Rename SlotCalculator::getValSlot() to SlotCalculator::getSlot(), SlotCalculator::insertValue() to SlotCalculator::getOrCreateSlot(), SlotCalculator::insertVal() to SlotCalculator::insertValue(), and SlotCalculator::doInsertVal() to SlotCalculator::doInsertValue(). llvm-svn: 9190 --- llvm/include/llvm/SlotCalculator.h | 23 +++++----- llvm/lib/Bytecode/Writer/ConstantWriter.cpp | 20 ++++----- llvm/lib/Bytecode/Writer/InstructionWriter.cpp | 16 +++---- llvm/lib/Bytecode/Writer/Writer.cpp | 16 +++---- llvm/lib/Target/Sparc/EmitAssembly.cpp | 2 +- llvm/lib/VMCore/AsmWriter.cpp | 12 +++--- llvm/lib/VMCore/SlotCalculator.cpp | 60 +++++++++++++------------- 7 files changed, 74 insertions(+), 75 deletions(-) diff --git a/llvm/include/llvm/SlotCalculator.h b/llvm/include/llvm/SlotCalculator.h index 9d88a02..3228ce2 100644 --- a/llvm/include/llvm/SlotCalculator.h +++ b/llvm/include/llvm/SlotCalculator.h @@ -39,8 +39,8 @@ public: 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 { @@ -58,19 +58,20 @@ public: 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 function declarations and // types that are available. diff --git a/llvm/lib/Bytecode/Writer/ConstantWriter.cpp b/llvm/lib/Bytecode/Writer/ConstantWriter.cpp index 539f3cd..c0c4137 100644 --- a/llvm/lib/Bytecode/Writer/ConstantWriter.cpp +++ b/llvm/lib/Bytecode/Writer/ConstantWriter.cpp @@ -20,7 +20,7 @@ void BytecodeWriter::outputType(const Type *T) { switch (T->getPrimitiveID()) { // Handle derived types now. case Type::FunctionTyID: { const FunctionType *MT = cast(T); - int Slot = Table.getValSlot(MT->getReturnType()); + int Slot = Table.getSlot(MT->getReturnType()); assert(Slot != -1 && "Type used but not available!!"); output_vbr((unsigned)Slot, Out); @@ -30,7 +30,7 @@ void BytecodeWriter::outputType(const Type *T) { // Output all of the arguments... FunctionType::ParamTypes::const_iterator I = MT->getParamTypes().begin(); for (; I != MT->getParamTypes().end(); ++I) { - Slot = Table.getValSlot(*I); + Slot = Table.getSlot(*I); assert(Slot != -1 && "Type used but not available!!"); output_vbr((unsigned)Slot, Out); } @@ -43,7 +43,7 @@ void BytecodeWriter::outputType(const Type *T) { case Type::ArrayTyID: { const ArrayType *AT = cast(T); - int Slot = Table.getValSlot(AT->getElementType()); + int Slot = Table.getSlot(AT->getElementType()); assert(Slot != -1 && "Type used but not available!!"); output_vbr((unsigned)Slot, Out); //std::cerr << "Type slot = " << Slot << " Type = " << T->getName() << endl; @@ -58,7 +58,7 @@ void BytecodeWriter::outputType(const Type *T) { // Output all of the element types... StructType::ElementTypes::const_iterator I = ST->getElementTypes().begin(); for (; I != ST->getElementTypes().end(); ++I) { - int Slot = Table.getValSlot(*I); + int Slot = Table.getSlot(*I); assert(Slot != -1 && "Type used but not available!!"); output_vbr((unsigned)Slot, Out); } @@ -70,7 +70,7 @@ void BytecodeWriter::outputType(const Type *T) { case Type::PointerTyID: { const PointerType *PT = cast(T); - int Slot = Table.getValSlot(PT->getElementType()); + int Slot = Table.getSlot(PT->getElementType()); assert(Slot != -1 && "Type used but not available!!"); output_vbr((unsigned)Slot, Out); break; @@ -103,10 +103,10 @@ bool BytecodeWriter::outputConstant(const Constant *CPV) { output_vbr(CE->getOpcode(), Out); // flags as an expr for (User::const_op_iterator OI = CE->op_begin(); OI != CE->op_end(); ++OI){ - int Slot = Table.getValSlot(*OI); + int Slot = Table.getSlot(*OI); assert(Slot != -1 && "Unknown constant used in ConstantExpr!!"); output_vbr((unsigned)Slot, Out); - Slot = Table.getValSlot((*OI)->getType()); + Slot = Table.getSlot((*OI)->getType()); output_vbr((unsigned)Slot, Out); } return false; @@ -146,7 +146,7 @@ bool BytecodeWriter::outputConstant(const Constant *CPV) { assert(size == cast(CPA->getType())->getNumElements() && "ConstantArray out of whack!"); for (unsigned i = 0; i < size; i++) { - int Slot = Table.getValSlot(CPA->getOperand(i)); + int Slot = Table.getSlot(CPA->getOperand(i)); assert(Slot != -1 && "Constant used but not available!!"); output_vbr((unsigned)Slot, Out); } @@ -158,7 +158,7 @@ bool BytecodeWriter::outputConstant(const Constant *CPV) { const std::vector &Vals = CPS->getValues(); for (unsigned i = 0; i < Vals.size(); ++i) { - int Slot = Table.getValSlot(Vals[i]); + int Slot = Table.getSlot(Vals[i]); assert(Slot != -1 && "Constant used but not available!!"); output_vbr((unsigned)Slot, Out); } @@ -169,7 +169,7 @@ bool BytecodeWriter::outputConstant(const Constant *CPV) { const ConstantPointer *CPP = cast(CPV); assert(!isa(CPP) && "Null should be already emitted!"); const ConstantPointerRef *CPR = cast(CPP); - int Slot = Table.getValSlot((Value*)CPR->getValue()); + int Slot = Table.getSlot((Value*)CPR->getValue()); assert(Slot != -1 && "Global used but not available!!"); output_vbr((unsigned)Slot, Out); break; diff --git a/llvm/lib/Bytecode/Writer/InstructionWriter.cpp b/llvm/lib/Bytecode/Writer/InstructionWriter.cpp index e3a8ffd..d5a2abf 100644 --- a/llvm/lib/Bytecode/Writer/InstructionWriter.cpp +++ b/llvm/lib/Bytecode/Writer/InstructionWriter.cpp @@ -33,13 +33,13 @@ static void outputInstructionFormat0(const Instruction *I, unsigned Opcode, output_vbr(NumArgs + (isa(I) || isa(I)), Out); for (unsigned i = 0; i < NumArgs; ++i) { - int Slot = Table.getValSlot(I->getOperand(i)); + int Slot = Table.getSlot(I->getOperand(i)); assert(Slot >= 0 && "No slot number for value!?!?"); output_vbr((unsigned)Slot, Out); } if (isa(I) || isa(I)) { - int Slot = Table.getValSlot(I->getType()); + int Slot = Table.getSlot(I->getType()); assert(Slot != -1 && "Cast/VarArg return type unknown?"); output_vbr((unsigned)Slot, Out); } @@ -72,7 +72,7 @@ static void outputInstrVarArgsCall(const Instruction *I, unsigned Opcode, // The type for the function has already been emitted in the type field of the // instruction. Just emit the slot # now. - int Slot = Table.getValSlot(I->getOperand(0)); + int Slot = Table.getSlot(I->getOperand(0)); assert(Slot >= 0 && "No slot number for value!?!?"); output_vbr((unsigned)Slot, Out); @@ -84,12 +84,12 @@ static void outputInstrVarArgsCall(const Instruction *I, unsigned Opcode, for (unsigned i = 1; i < NumArgs; ++i) { // Output Arg Type ID - Slot = Table.getValSlot(I->getOperand(i)->getType()); + Slot = Table.getSlot(I->getOperand(i)->getType()); assert(Slot >= 0 && "No slot number for value!?!?"); output_vbr((unsigned)Slot, Out); // Output arg ID itself - Slot = Table.getValSlot(I->getOperand(i)); + Slot = Table.getSlot(I->getOperand(i)); assert(Slot >= 0 && "No slot number for value!?!?"); output_vbr((unsigned)Slot, Out); } @@ -176,7 +176,7 @@ void BytecodeWriter::processInstruction(const Instruction &I) { for (unsigned i = 0; i < NumOperands; ++i) { const Value *Def = I.getOperand(i); - int slot = Table.getValSlot(Def); + int slot = Table.getSlot(Def); assert(slot != -1 && "Broken bytecode!"); if (slot > MaxOpSlot) MaxOpSlot = slot; if (i < 3) Slots[i] = slot; @@ -204,7 +204,7 @@ void BytecodeWriter::processInstruction(const Instruction &I) { } unsigned Type; - int Slot = Table.getValSlot(Ty); + int Slot = Table.getSlot(Ty); assert(Slot != -1 && "Type not available!!?!"); Type = (unsigned)Slot; @@ -217,7 +217,7 @@ void BytecodeWriter::processInstruction(const Instruction &I) { if (isa(I) || isa(I)) { // Cast has to encode the destination type as the second argument in the // packet, or else we won't know what type to cast to! - Slots[1] = Table.getValSlot(I.getType()); + Slots[1] = Table.getSlot(I.getType()); assert(Slots[1] != -1 && "Cast return type unknown?"); if (Slots[1] > MaxOpSlot) MaxOpSlot = Slots[1]; NumOperands++; diff --git a/llvm/lib/Bytecode/Writer/Writer.cpp b/llvm/lib/Bytecode/Writer/Writer.cpp index 1e6d63a..0304ab6 100644 --- a/llvm/lib/Bytecode/Writer/Writer.cpp +++ b/llvm/lib/Bytecode/Writer/Writer.cpp @@ -105,7 +105,7 @@ void BytecodeWriter::outputConstantsInPlane(const std::vector output_vbr(NC, Out); // Output the Type ID Number... - int Slot = Table.getValSlot(Plane.front()->getType()); + int Slot = Table.getSlot(Plane.front()->getType()); assert (Slot != -1 && "Type in constant pool but not in function!!"); output_vbr((unsigned)Slot, Out); @@ -174,7 +174,7 @@ void BytecodeWriter::outputModuleInfoBlock(const Module *M) { // Output the types for the global variables in the module... for (Module::const_giterator I = M->gbegin(), End = M->gend(); I != End;++I) { - int Slot = Table.getValSlot(I->getType()); + int Slot = Table.getSlot(I->getType()); assert(Slot != -1 && "Module global vars is broken!"); // Fields: bit0 = isConstant, bit1 = hasInitializer, bit2,3=Linkage, @@ -185,21 +185,21 @@ void BytecodeWriter::outputModuleInfoBlock(const Module *M) { // If we have an initializer, output it now. if (I->hasInitializer()) { - Slot = Table.getValSlot((Value*)I->getInitializer()); + Slot = Table.getSlot((Value*)I->getInitializer()); assert(Slot != -1 && "No slot for global var initializer!"); output_vbr((unsigned)Slot, Out); } } - output_vbr((unsigned)Table.getValSlot(Type::VoidTy), Out); + output_vbr((unsigned)Table.getSlot(Type::VoidTy), Out); // Output the types of the functions in this module... for (Module::const_iterator I = M->begin(), End = M->end(); I != End; ++I) { - int Slot = Table.getValSlot(I->getType()); + int Slot = Table.getSlot(I->getType()); assert(Slot != -1 && "Module const pool is broken!"); assert(Slot >= Type::FirstDerivedTyID && "Derived type not in range!"); output_vbr((unsigned)Slot, Out); } - output_vbr((unsigned)Table.getValSlot(Type::VoidTy), Out); + output_vbr((unsigned)Table.getSlot(Type::VoidTy), Out); align32(Out); } @@ -248,13 +248,13 @@ void BytecodeWriter::outputSymbolTable(const SymbolTable &MST) { // Symtab block header: [num entries][type id number] output_vbr(MST.type_size(TI->first), Out); - Slot = Table.getValSlot(TI->first); + Slot = Table.getSlot(TI->first); assert(Slot != -1 && "Type in symtab, but not in table!"); output_vbr((unsigned)Slot, Out); for (; I != End; ++I) { // Symtab entry: [def slot #][name] - Slot = Table.getValSlot(I->second); + Slot = Table.getSlot(I->second); assert(Slot != -1 && "Value in symtab but has no slot number!!"); output_vbr((unsigned)Slot, Out); output(I->first, Out, false); // Don't force alignment... diff --git a/llvm/lib/Target/Sparc/EmitAssembly.cpp b/llvm/lib/Target/Sparc/EmitAssembly.cpp index 029935d..bbcb12e 100644 --- a/llvm/lib/Target/Sparc/EmitAssembly.cpp +++ b/llvm/lib/Target/Sparc/EmitAssembly.cpp @@ -148,7 +148,7 @@ public: // Qualify all internal names with a unique id. if (!isExternal(V)) { - int valId = idTable->Table.getValSlot(V); + int valId = idTable->Table.getSlot(V); if (valId == -1) { GlobalIdTable::ValIdMapConstIterator I = idTable->valToIdMap.find(V); if (I == idTable->valToIdMap.end()) diff --git a/llvm/lib/VMCore/AsmWriter.cpp b/llvm/lib/VMCore/AsmWriter.cpp index 9437b59..3601dff 100644 --- a/llvm/lib/VMCore/AsmWriter.cpp +++ b/llvm/lib/VMCore/AsmWriter.cpp @@ -357,7 +357,7 @@ static void WriteConstantInt(std::ostream &Out, const Constant *CV, if (V->hasName()) { Out << getLLVMName(V->getName()); } else if (Table) { - int Slot = Table->getValSlot(V); + int Slot = Table->getSlot(V); if (Slot >= 0) Out << "%" << Slot; else @@ -405,7 +405,7 @@ static void WriteAsOperandInternal(std::ostream &Out, const Value *V, } else { int Slot; if (Table) { - Slot = Table->getValSlot(V); + Slot = Table->getSlot(V); } else { if (const Type *Ty = dyn_cast(V)) { Out << Ty->getDescription(); @@ -415,7 +415,7 @@ static void WriteAsOperandInternal(std::ostream &Out, const Value *V, Table = createSlotCalculator(V); if (Table == 0) { Out << "BAD VALUE TYPE!"; return; } - Slot = Table->getValSlot(V); + Slot = Table->getSlot(V); delete Table; } if (Slot >= 0) Out << "%" << Slot; @@ -706,7 +706,7 @@ void AssemblyWriter::printArgument(const Argument *Arg) { // Output name, if available... if (Arg->hasName()) Out << " " << getLLVMName(Arg->getName()); - else if (Table.getValSlot(Arg) < 0) + else if (Table.getSlot(Arg) < 0) Out << ""; } @@ -716,7 +716,7 @@ void AssemblyWriter::printBasicBlock(const BasicBlock *BB) { if (BB->hasName()) { // Print out the label if it exists... Out << "\n" << BB->getName() << ":"; } else if (!BB->use_empty()) { // Don't print block # of no uses... - int Slot = Table.getValSlot(BB); + int Slot = Table.getSlot(BB); Out << "\n;