[llvm] r319722 - MachineFrameInfo: Cleanup some parameter naming inconsistencies; NFC
Matthias Braun via llvm-commits
llvm-commits at lists.llvm.org
Mon Dec 4 17:18:15 PST 2017
Author: matze
Date: Mon Dec 4 17:18:15 2017
New Revision: 319722
URL: http://llvm.org/viewvc/llvm-project?rev=319722&view=rev
Log:
MachineFrameInfo: Cleanup some parameter naming inconsistencies; NFC
Consistently use the same parameter names as the names of the affected
fields. This avoids some unintuitive abbreviations like `isSS`.
Modified:
llvm/trunk/include/llvm/CodeGen/MachineFrameInfo.h
llvm/trunk/lib/CodeGen/MachineFrameInfo.cpp
Modified: llvm/trunk/include/llvm/CodeGen/MachineFrameInfo.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/CodeGen/MachineFrameInfo.h?rev=319722&r1=319721&r2=319722&view=diff
==============================================================================
--- llvm/trunk/include/llvm/CodeGen/MachineFrameInfo.h (original)
+++ llvm/trunk/include/llvm/CodeGen/MachineFrameInfo.h Mon Dec 4 17:18:15 2017
@@ -115,7 +115,7 @@ class MachineFrameInfo {
/// slot can't alias any LLVM IR value. This is very similar to a Spill
/// Slot, but is created by statepoint lowering is SelectionDAG, not the
/// register allocator.
- bool isStatepointSpillSlot;
+ bool isStatepointSpillSlot = false;
/// Identifier for stack memory type analagous to address space. If this is
/// non-0, the meaning is target defined. Offsets cannot be directly
@@ -131,7 +131,7 @@ class MachineFrameInfo {
// If true, the object was mapped into the local frame
// block and doesn't need additional handling for allocation beyond that.
- bool PreAllocated;
+ bool PreAllocated = false;
// If true, an LLVM IR value might point to this object.
// Normally, spill slots and fixed-offset objects don't alias IR-accessible
@@ -140,17 +140,17 @@ class MachineFrameInfo {
bool isAliased;
/// If true, the object has been zero-extended.
- bool isZExt;
+ bool isZExt = false;
/// If true, the object has been zero-extended.
- bool isSExt;
+ bool isSExt = false;
- StackObject(uint64_t Sz, unsigned Al, int64_t SP, bool IM,
- bool isSS, const AllocaInst *Val, bool Aliased, uint8_t ID = 0)
- : SPOffset(SP), Size(Sz), Alignment(Al), isImmutable(IM),
- isSpillSlot(isSS), isStatepointSpillSlot(false), StackID(ID),
- Alloca(Val),
- PreAllocated(false), isAliased(Aliased), isZExt(false), isSExt(false) {}
+ StackObject(uint64_t Size, unsigned Alignment, int64_t SPOffset,
+ bool IsImmutable, bool IsSpillSlot, const AllocaInst *Alloca,
+ bool IsAliased, uint8_t StackID = 0)
+ : SPOffset(SPOffset), Size(Size), Alignment(Alignment),
+ isImmutable(IsImmutable), isSpillSlot(IsSpillSlot),
+ StackID(StackID), Alloca(Alloca), isAliased(IsAliased) {}
};
/// The alignment of the stack.
@@ -573,13 +573,13 @@ public:
/// All fixed objects should be created before other objects are created for
/// efficiency. By default, fixed objects are not pointed to by LLVM IR
/// values. This returns an index with a negative value.
- int CreateFixedObject(uint64_t Size, int64_t SPOffset, bool Immutable,
+ int CreateFixedObject(uint64_t Size, int64_t SPOffset, bool IsImmutable,
bool isAliased = false);
/// Create a spill slot at a fixed location on the stack.
/// Returns an index with a negative value.
int CreateFixedSpillStackObject(uint64_t Size, int64_t SPOffset,
- bool Immutable = false);
+ bool IsImmutable = false);
/// Returns true if the specified index corresponds to a fixed stack object.
bool isFixedObjectIndex(int ObjectIdx) const {
@@ -605,10 +605,10 @@ public:
}
/// Marks the immutability of an object.
- void setIsImmutableObjectIndex(int ObjectIdx, bool Immutable) {
+ void setIsImmutableObjectIndex(int ObjectIdx, bool IsImmutable) {
assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
"Invalid Object Idx!");
- Objects[ObjectIdx+NumFixedObjects].isImmutable = Immutable;
+ Objects[ObjectIdx+NumFixedObjects].isImmutable = IsImmutable;
}
/// Returns true if the specified index corresponds to a spill slot.
@@ -660,7 +660,7 @@ public:
/// Create a new statically sized stack object, returning
/// a nonnegative identifier to represent it.
- int CreateStackObject(uint64_t Size, unsigned Alignment, bool isSS,
+ int CreateStackObject(uint64_t Size, unsigned Alignment, bool isSpillSlot,
const AllocaInst *Alloca = nullptr, uint8_t ID = 0);
/// Create a new statically sized stack object that represents a spill slot,
Modified: llvm/trunk/lib/CodeGen/MachineFrameInfo.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/MachineFrameInfo.cpp?rev=319722&r1=319721&r2=319722&view=diff
==============================================================================
--- llvm/trunk/lib/CodeGen/MachineFrameInfo.cpp (original)
+++ llvm/trunk/lib/CodeGen/MachineFrameInfo.cpp Mon Dec 4 17:18:15 2017
@@ -47,12 +47,13 @@ static inline unsigned clampStackAlignme
}
int MachineFrameInfo::CreateStackObject(uint64_t Size, unsigned Alignment,
- bool isSS, const AllocaInst *Alloca,
- uint8_t ID) {
+ bool IsSpillSlot,
+ const AllocaInst *Alloca,
+ uint8_t StackID) {
assert(Size != 0 && "Cannot allocate zero size stack objects!");
Alignment = clampStackAlignment(!StackRealignable, Alignment, StackAlignment);
- Objects.push_back(StackObject(Size, Alignment, 0, false, isSS, Alloca,
- !isSS, ID));
+ Objects.push_back(StackObject(Size, Alignment, 0, false, IsSpillSlot, Alloca,
+ !IsSpillSlot, StackID));
int Index = (int)Objects.size() - NumFixedObjects - 1;
assert(Index >= 0 && "Bad frame index!");
ensureMaxAlignment(Alignment);
@@ -78,7 +79,7 @@ int MachineFrameInfo::CreateVariableSize
}
int MachineFrameInfo::CreateFixedObject(uint64_t Size, int64_t SPOffset,
- bool Immutable, bool isAliased) {
+ bool IsImmutable, bool IsAliased) {
assert(Size != 0 && "Cannot allocate zero size fixed stack objects!");
// The alignment of the frame index can be determined from its offset from
// the incoming frame position. If the frame object is at offset 32 and
@@ -86,23 +87,24 @@ int MachineFrameInfo::CreateFixedObject(
// object is 16-byte aligned. Note that unlike the non-fixed case, if the
// stack needs realignment, we can't assume that the stack will in fact be
// aligned.
- unsigned Align = MinAlign(SPOffset, ForcedRealign ? 1 : StackAlignment);
- Align = clampStackAlignment(!StackRealignable, Align, StackAlignment);
- Objects.insert(Objects.begin(), StackObject(Size, Align, SPOffset, Immutable,
- /*isSS*/ false,
- /*Alloca*/ nullptr, isAliased));
+ unsigned Alignment = MinAlign(SPOffset, ForcedRealign ? 1 : StackAlignment);
+ Alignment = clampStackAlignment(!StackRealignable, Alignment, StackAlignment);
+ Objects.insert(Objects.begin(),
+ StackObject(Size, Alignment, SPOffset, IsImmutable,
+ /*isSpillSlot=*/false, /*Alloca=*/nullptr,
+ IsAliased));
return -++NumFixedObjects;
}
int MachineFrameInfo::CreateFixedSpillStackObject(uint64_t Size,
int64_t SPOffset,
- bool Immutable) {
- unsigned Align = MinAlign(SPOffset, ForcedRealign ? 1 : StackAlignment);
- Align = clampStackAlignment(!StackRealignable, Align, StackAlignment);
- Objects.insert(Objects.begin(), StackObject(Size, Align, SPOffset, Immutable,
- /*isSS*/ true,
- /*Alloca*/ nullptr,
- /*isAliased*/ false));
+ bool IsImmutable) {
+ unsigned Alignment = MinAlign(SPOffset, ForcedRealign ? 1 : StackAlignment);
+ Alignment = clampStackAlignment(!StackRealignable, Alignment, StackAlignment);
+ Objects.insert(Objects.begin(),
+ StackObject(Size, Alignment, SPOffset, IsImmutable,
+ /*IsSpillSlot=*/true, /*Alloca=*/nullptr,
+ /*IsAliased=*/false));
return -++NumFixedObjects;
}
More information about the llvm-commits
mailing list