6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-14 11:32:34 +00:00
Code Issues Projects Releases Wiki Activity

remove function names from comments and clean up; NFC

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@239680 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Sanjay Patel 2015-06-13 15:32:45 +00:00
parent 4a9a71e3ec
commit ea58c7de01
1 changed files with 40 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

98
lib/CodeGen/MachineFunction.cpp
View File

@ -45,7 +45,7 @@ using namespace llvm;
// MachineFunction implementation // MachineFunction implementation
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Out of line virtual method. // Out-of-line virtual method.
MachineFunctionInfo::~MachineFunctionInfo() {} MachineFunctionInfo::~MachineFunctionInfo() {}
void ilist_traits<MachineBasicBlock>::deleteNode(MachineBasicBlock *MBB) { void ilist_traits<MachineBasicBlock>::deleteNode(MachineBasicBlock *MBB) {
@ -114,8 +114,8 @@ MachineFunction::~MachineFunction() {
} }
} }
/// getOrCreateJumpTableInfo - Get the JumpTableInfo for this function, if it /// Get the JumpTableInfo for this function.
/// does already exist, allocate one. /// If it does not already exist, allocate one.
MachineJumpTableInfo *MachineFunction:: MachineJumpTableInfo *MachineFunction::
getOrCreateJumpTableInfo(unsigned EntryKind) { getOrCreateJumpTableInfo(unsigned EntryKind) {
if (JumpTableInfo) return JumpTableInfo; if (JumpTableInfo) return JumpTableInfo;
@ -130,11 +130,10 @@ bool MachineFunction::shouldSplitStack() {
return getFunction()->hasFnAttribute("split-stack"); return getFunction()->hasFnAttribute("split-stack");
} }
/// RenumberBlocks - This discards all of the MachineBasicBlock numbers and /// This discards all of the MachineBasicBlock numbers and recomputes them.
/// recomputes them. This guarantees that the MBB numbers are sequential, /// This guarantees that the MBB numbers are sequential, dense, and match the
/// dense, and match the ordering of the blocks within the function. If a /// ordering of the blocks within the function. If a specific MachineBasicBlock
/// specific MachineBasicBlock is specified, only that block and those after /// is specified, only that block and those after it are renumbered.
/// it are renumbered.
void MachineFunction::RenumberBlocks(MachineBasicBlock *MBB) { void MachineFunction::RenumberBlocks(MachineBasicBlock *MBB) {
if (empty()) { MBBNumbering.clear(); return; } if (empty()) { MBBNumbering.clear(); return; }
MachineFunction::iterator MBBI, E = end(); MachineFunction::iterator MBBI, E = end();
@ -172,9 +171,7 @@ void MachineFunction::RenumberBlocks(MachineBasicBlock *MBB) {
MBBNumbering.resize(BlockNo); MBBNumbering.resize(BlockNo);
} }
/// CreateMachineInstr - Allocate a new MachineInstr. Use this instead /// Allocate a new MachineInstr. Use this instead of `new MachineInstr'.
/// of `new MachineInstr'.
///
MachineInstr * MachineInstr *
MachineFunction::CreateMachineInstr(const MCInstrDesc &MCID, MachineFunction::CreateMachineInstr(const MCInstrDesc &MCID,
DebugLoc DL, bool NoImp) { DebugLoc DL, bool NoImp) {
@ -182,17 +179,15 @@ MachineFunction::CreateMachineInstr(const MCInstrDesc &MCID,
MachineInstr(*this, MCID, DL, NoImp); MachineInstr(*this, MCID, DL, NoImp);
} }
/// CloneMachineInstr - Create a new MachineInstr which is a copy of the /// Create a new MachineInstr which is a copy of the 'Orig' instruction,
/// 'Orig' instruction, identical in all ways except the instruction /// identical in all ways except the instruction has no parent, prev, or next.
/// has no parent, prev, or next.
///
MachineInstr * MachineInstr *
MachineFunction::CloneMachineInstr(const MachineInstr *Orig) { MachineFunction::CloneMachineInstr(const MachineInstr *Orig) {
return new (InstructionRecycler.Allocate<MachineInstr>(Allocator)) return new (InstructionRecycler.Allocate<MachineInstr>(Allocator))
MachineInstr(*this, *Orig); MachineInstr(*this, *Orig);
} }
/// DeleteMachineInstr - Delete the given MachineInstr. /// Delete the given MachineInstr.
/// ///
/// This function also serves as the MachineInstr destructor - the real /// This function also serves as the MachineInstr destructor - the real
/// ~MachineInstr() destructor must be empty. /// ~MachineInstr() destructor must be empty.
@ -208,17 +203,15 @@ MachineFunction::DeleteMachineInstr(MachineInstr *MI) {
InstructionRecycler.Deallocate(Allocator, MI); InstructionRecycler.Deallocate(Allocator, MI);
} }
/// CreateMachineBasicBlock - Allocate a new MachineBasicBlock. Use this /// Allocate a new MachineBasicBlock. Use this instead of
/// instead of `new MachineBasicBlock'. /// `new MachineBasicBlock'.
///
MachineBasicBlock * MachineBasicBlock *
MachineFunction::CreateMachineBasicBlock(const BasicBlock *bb) { MachineFunction::CreateMachineBasicBlock(const BasicBlock *bb) {
return new (BasicBlockRecycler.Allocate<MachineBasicBlock>(Allocator)) return new (BasicBlockRecycler.Allocate<MachineBasicBlock>(Allocator))
MachineBasicBlock(*this, bb); MachineBasicBlock(*this, bb);
} }
/// DeleteMachineBasicBlock - Delete the given MachineBasicBlock. /// Delete the given MachineBasicBlock.
///
void void
MachineFunction::DeleteMachineBasicBlock(MachineBasicBlock *MBB) { MachineFunction::DeleteMachineBasicBlock(MachineBasicBlock *MBB) {
assert(MBB->getParent() == this && "MBB parent mismatch!"); assert(MBB->getParent() == this && "MBB parent mismatch!");
@ -430,7 +423,7 @@ void MachineFunction::viewCFGOnly() const
#endif // NDEBUG #endif // NDEBUG
} }
/// addLiveIn - Add the specified physical register as a live-in value and /// Add the specified physical register as a live-in value and
/// create a corresponding virtual register for it. /// create a corresponding virtual register for it.
unsigned MachineFunction::addLiveIn(unsigned PReg, unsigned MachineFunction::addLiveIn(unsigned PReg,
const TargetRegisterClass *RC) { const TargetRegisterClass *RC) {
@ -454,7 +447,7 @@ unsigned MachineFunction::addLiveIn(unsigned PReg,
return VReg; return VReg;
} }
/// getJTISymbol - Return the MCSymbol for the specified non-empty jump table. /// Return the MCSymbol for the specified non-empty jump table.
/// If isLinkerPrivate is specified, an 'l' label is returned, otherwise a /// If isLinkerPrivate is specified, an 'l' label is returned, otherwise a
/// normal 'L' label is returned. /// normal 'L' label is returned.
MCSymbol *MachineFunction::getJTISymbol(unsigned JTI, MCContext &Ctx, MCSymbol *MachineFunction::getJTISymbol(unsigned JTI, MCContext &Ctx,
@ -471,8 +464,7 @@ MCSymbol *MachineFunction::getJTISymbol(unsigned JTI, MCContext &Ctx,
return Ctx.getOrCreateSymbol(Name); return Ctx.getOrCreateSymbol(Name);
} }
/// getPICBaseSymbol - Return a function-local symbol to represent the PIC /// Return a function-local symbol to represent the PIC base.
/// base.
MCSymbol *MachineFunction::getPICBaseSymbol() const { MCSymbol *MachineFunction::getPICBaseSymbol() const {
const DataLayout *DL = getTarget().getDataLayout(); const DataLayout *DL = getTarget().getDataLayout();
return Ctx.getOrCreateSymbol(Twine(DL->getPrivateGlobalPrefix())+ return Ctx.getOrCreateSymbol(Twine(DL->getPrivateGlobalPrefix())+
@ -483,8 +475,7 @@ MCSymbol *MachineFunction::getPICBaseSymbol() const {
// MachineFrameInfo implementation // MachineFrameInfo implementation
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// ensureMaxAlignment - Make sure the function is at least Align bytes /// Make sure the function is at least Align bytes aligned.
/// aligned.
void MachineFrameInfo::ensureMaxAlignment(unsigned Align) { void MachineFrameInfo::ensureMaxAlignment(unsigned Align) {
if (!StackRealignable || !RealignOption) if (!StackRealignable || !RealignOption)
assert(Align <= StackAlignment && assert(Align <= StackAlignment &&
@ -492,7 +483,7 @@ void MachineFrameInfo::ensureMaxAlignment(unsigned Align) {
if (MaxAlignment < Align) MaxAlignment = Align; if (MaxAlignment < Align) MaxAlignment = Align;
} }
/// clampStackAlignment - Clamp the alignment if requested and emit a warning. /// Clamp the alignment if requested and emit a warning.
static inline unsigned clampStackAlignment(bool ShouldClamp, unsigned Align, static inline unsigned clampStackAlignment(bool ShouldClamp, unsigned Align,
unsigned StackAlign) { unsigned StackAlign) {
if (!ShouldClamp || Align <= StackAlign) if (!ShouldClamp || Align <= StackAlign)
@ -503,9 +494,8 @@ static inline unsigned clampStackAlignment(bool ShouldClamp, unsigned Align,
return StackAlign; return StackAlign;
} }
/// CreateStackObject - Create a new statically sized stack object, returning /// Create a new statically sized stack object, returning a nonnegative
/// a nonnegative identifier to represent it. /// identifier to represent it.
///
int MachineFrameInfo::CreateStackObject(uint64_t Size, unsigned Alignment, int MachineFrameInfo::CreateStackObject(uint64_t Size, unsigned Alignment,
bool isSS, const AllocaInst *Alloca) { bool isSS, const AllocaInst *Alloca) {
assert(Size != 0 && "Cannot allocate zero size stack objects!"); assert(Size != 0 && "Cannot allocate zero size stack objects!");
@ -519,10 +509,8 @@ int MachineFrameInfo::CreateStackObject(uint64_t Size, unsigned Alignment,
return Index; return Index;
} }
/// CreateSpillStackObject - Create a new statically sized stack object that /// Create a new statically sized stack object that represents a spill slot,
/// represents a spill slot, returning a nonnegative identifier to represent /// returning a nonnegative identifier to represent it.
/// it.
///
int MachineFrameInfo::CreateSpillStackObject(uint64_t Size, int MachineFrameInfo::CreateSpillStackObject(uint64_t Size,
unsigned Alignment) { unsigned Alignment) {
Alignment = clampStackAlignment(!StackRealignable || !RealignOption, Alignment = clampStackAlignment(!StackRealignable || !RealignOption,
@ -533,11 +521,9 @@ int MachineFrameInfo::CreateSpillStackObject(uint64_t Size,
return Index; return Index;
} }
/// CreateVariableSizedObject - Notify the MachineFrameInfo object that a /// Notify the MachineFrameInfo object that a variable sized object has been
/// variable sized object has been created. This must be created whenever a /// created. This must be created whenever a variable sized object is created,
/// variable sized object is created, whether or not the index returned is /// whether or not the index returned is actually used.
/// actually used.
///
int MachineFrameInfo::CreateVariableSizedObject(unsigned Alignment, int MachineFrameInfo::CreateVariableSizedObject(unsigned Alignment,
const AllocaInst *Alloca) { const AllocaInst *Alloca) {
HasVarSizedObjects = true; HasVarSizedObjects = true;
@ -548,11 +534,10 @@ int MachineFrameInfo::CreateVariableSizedObject(unsigned Alignment,
return (int)Objects.size()-NumFixedObjects-1; return (int)Objects.size()-NumFixedObjects-1;
} }
/// CreateFixedObject - Create a new object at a fixed location on the stack. /// Create a new object at a fixed location on the stack.
/// All fixed objects should be created before other objects are created for /// All fixed objects should be created before other objects are created for
/// efficiency. By default, fixed objects are immutable. This returns an /// efficiency. By default, fixed objects are immutable. This returns an
/// index with a negative value. /// index with a negative value.
///
int MachineFrameInfo::CreateFixedObject(uint64_t Size, int64_t SPOffset, int MachineFrameInfo::CreateFixedObject(uint64_t Size, int64_t SPOffset,
bool Immutable, bool isAliased) { bool Immutable, bool isAliased) {
assert(Size != 0 && "Cannot allocate zero size fixed stack objects!"); assert(Size != 0 && "Cannot allocate zero size fixed stack objects!");
@ -569,8 +554,8 @@ int MachineFrameInfo::CreateFixedObject(uint64_t Size, int64_t SPOffset,
return -++NumFixedObjects; return -++NumFixedObjects;
} }
/// CreateFixedSpillStackObject - Create a spill slot at a fixed location /// Create a spill slot at a fixed location on the stack.
/// on the stack. Returns an index with a negative value. /// Returns an index with a negative value.
int MachineFrameInfo::CreateFixedSpillStackObject(uint64_t Size, int MachineFrameInfo::CreateFixedSpillStackObject(uint64_t Size,
int64_t SPOffset) { int64_t SPOffset) {
unsigned Align = MinAlign(SPOffset, StackAlignment); unsigned Align = MinAlign(SPOffset, StackAlignment);
@ -700,7 +685,7 @@ void MachineFrameInfo::dump(const MachineFunction &MF) const {
// MachineJumpTableInfo implementation // MachineJumpTableInfo implementation
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// getEntrySize - Return the size of each entry in the jump table. /// Return the size of each entry in the jump table.
unsigned MachineJumpTableInfo::getEntrySize(const DataLayout &TD) const { unsigned MachineJumpTableInfo::getEntrySize(const DataLayout &TD) const {
// The size of a jump table entry is 4 bytes unless the entry is just the // The size of a jump table entry is 4 bytes unless the entry is just the
// address of a block, in which case it is the pointer size. // address of a block, in which case it is the pointer size.
@ -719,7 +704,7 @@ unsigned MachineJumpTableInfo::getEntrySize(const DataLayout &TD) const {
llvm_unreachable("Unknown jump table encoding!"); llvm_unreachable("Unknown jump table encoding!");
} }
/// getEntryAlignment - Return the alignment of each entry in the jump table. /// Return the alignment of each entry in the jump table.
unsigned MachineJumpTableInfo::getEntryAlignment(const DataLayout &TD) const { unsigned MachineJumpTableInfo::getEntryAlignment(const DataLayout &TD) const {
// The alignment of a jump table entry is the alignment of int32 unless the // The alignment of a jump table entry is the alignment of int32 unless the
// entry is just the address of a block, in which case it is the pointer // entry is just the address of a block, in which case it is the pointer
@ -739,8 +724,7 @@ unsigned MachineJumpTableInfo::getEntryAlignment(const DataLayout &TD) const {
llvm_unreachable("Unknown jump table encoding!"); llvm_unreachable("Unknown jump table encoding!");
} }
/// createJumpTableIndex - Create a new jump table entry in the jump table info. /// Create a new jump table entry in the jump table info.
///
unsigned MachineJumpTableInfo::createJumpTableIndex( unsigned MachineJumpTableInfo::createJumpTableIndex(
const std::vector<MachineBasicBlock*> &DestBBs) { const std::vector<MachineBasicBlock*> &DestBBs) {
assert(!DestBBs.empty() && "Cannot create an empty jump table!"); assert(!DestBBs.empty() && "Cannot create an empty jump table!");
@ -748,8 +732,8 @@ unsigned MachineJumpTableInfo::createJumpTableIndex(
return JumpTables.size()-1; return JumpTables.size()-1;
} }
/// ReplaceMBBInJumpTables - If Old is the target of any jump tables, update /// If Old is the target of any jump tables, update the jump tables to branch
/// the jump tables to branch to New instead. /// to New instead.
bool MachineJumpTableInfo::ReplaceMBBInJumpTables(MachineBasicBlock *Old, bool MachineJumpTableInfo::ReplaceMBBInJumpTables(MachineBasicBlock *Old,
MachineBasicBlock *New) { MachineBasicBlock *New) {
assert(Old != New && "Not making a change?"); assert(Old != New && "Not making a change?");
@ -759,8 +743,8 @@ bool MachineJumpTableInfo::ReplaceMBBInJumpTables(MachineBasicBlock *Old,
return MadeChange; return MadeChange;
} }
/// ReplaceMBBInJumpTable - If Old is a target of the jump tables, update /// If Old is a target of the jump tables, update the jump table to branch to
/// the jump table to branch to New instead. /// New instead.
bool MachineJumpTableInfo::ReplaceMBBInJumpTable(unsigned Idx, bool MachineJumpTableInfo::ReplaceMBBInJumpTable(unsigned Idx,
MachineBasicBlock *Old, MachineBasicBlock *Old,
MachineBasicBlock *New) { MachineBasicBlock *New) {
@ -858,8 +842,8 @@ MachineConstantPool::~MachineConstantPool() {
delete *I; delete *I;
} }
/// CanShareConstantPoolEntry - Test whether the given two constants /// Test whether the given two constants can be allocated the same constant pool
/// can be allocated the same constant pool entry. /// entry.
static bool CanShareConstantPoolEntry(const Constant *A, const Constant *B, static bool CanShareConstantPoolEntry(const Constant *A, const Constant *B,
const DataLayout *TD) { const DataLayout *TD) {
// Handle the trivial case quickly. // Handle the trivial case quickly.
@ -901,10 +885,8 @@ static bool CanShareConstantPoolEntry(const Constant *A, const Constant *B,
return A == B; return A == B;
} }
/// getConstantPoolIndex - Create a new entry in the constant pool or return /// Create a new entry in the constant pool or return an existing one.
/// an existing one. User must specify the log2 of the minimum required /// User must specify the log2 of the minimum required alignment for the object.
/// alignment for the object.
///
unsigned MachineConstantPool::getConstantPoolIndex(const Constant *C, unsigned MachineConstantPool::getConstantPoolIndex(const Constant *C,
unsigned Alignment) { unsigned Alignment) {
assert(Alignment && "Alignment must be specified!"); assert(Alignment && "Alignment must be specified!");