59 if (CFSize >= ((1 << 8) - 1) * 4 / 2)
70 unsigned ScratchReg,
unsigned MIFlags) {
73 if (std::abs(NumBytes) > 508 * 3) {
78 if (ScratchReg == ARM::NoRegister)
82 if (ST.genExecuteOnly()) {
83 unsigned XOInstr = ST.useMovt() ? ARM::t2MOVi32imm : ARM::tMOVi32imm;
127 unsigned Amount =
TII.getFrameSize(Old);
136 if (Opc == ARM::ADJCALLSTACKDOWN || Opc == ARM::tADJCALLSTACKDOWN) {
139 assert(Opc == ARM::ADJCALLSTACKUP || Opc == ARM::tADJCALLSTACKUP);
160 assert(NumBytes >= ArgRegsSaveSize &&
161 "ArgRegsSaveSize is included in NumBytes");
173 NumBytes = (NumBytes + 3) & ~3;
178 unsigned FRSize = 0, GPRCS1Size = 0, GPRCS2Size = 0, DPRCSSize = 0;
179 int FramePtrSpillFI = 0;
181 if (ArgRegsSaveSize) {
184 CFAOffset += ArgRegsSaveSize;
193 if (NumBytes - ArgRegsSaveSize != 0) {
195 -(NumBytes - ArgRegsSaveSize),
197 CFAOffset += NumBytes - ArgRegsSaveSize;
207 bool HasFrameRecordArea =
hasFP(MF) && ARM::hGPRRegClass.contains(
FramePtr);
211 int FI =
I.getFrameIdx();
213 FramePtrSpillFI = FI;
216 if (HasFrameRecordArea) {
230 if (HasFrameRecordArea) {
247 if (HasFrameRecordArea) {
252 std::advance(
MBBI, 2);
283 unsigned DPRCSOffset = NumBytes - ArgRegsSaveSize -
284 (FRSize + GPRCS1Size + GPRCS2Size + DPRCSSize);
285 unsigned GPRCS2Offset = DPRCSOffset + DPRCSSize;
286 unsigned GPRCS1Offset = GPRCS2Offset + GPRCS2Size;
287 bool HasFP =
hasFP(MF);
291 if (HasFrameRecordArea)
296 NumBytes = DPRCSOffset;
298 int FramePtrOffsetInBlock = 0;
299 unsigned adjustedGPRCS1Size = GPRCS1Size;
300 if (GPRCS1Size > 0 && GPRCS2Size == 0 &&
302 FramePtrOffsetInBlock = NumBytes;
303 adjustedGPRCS1Size += NumBytes;
306 CFAOffset += adjustedGPRCS1Size;
311 HasFrameRecordArea ? std::next(FRPush) : std::next(GPRCS1Push);
312 if (HasFrameRecordArea) {
320 FramePtrOffsetInBlock +=
324 .
addImm(FramePtrOffsetInBlock / 4)
329 if(FramePtrOffsetInBlock) {
331 nullptr,
MRI->getDwarfRegNum(
FramePtr,
true), (CFAOffset - FramePtrOffsetInBlock)));
332 BuildMI(
MBB, AfterPush, dl,
TII.get(TargetOpcode::CFI_INSTRUCTION))
339 BuildMI(
MBB, AfterPush, dl,
TII.get(TargetOpcode::CFI_INSTRUCTION))
350 if (GPRCS1Size > 0) {
352 if (adjustedGPRCS1Size) {
355 BuildMI(
MBB, Pos, dl,
TII.get(TargetOpcode::CFI_INSTRUCTION))
361 int FI =
I.getFrameIdx();
382 BuildMI(
MBB, Pos, dl,
TII.get(TargetOpcode::CFI_INSTRUCTION))
391 if (GPRCS2Size > 0) {
393 for (
auto &
I : CSI) {
395 int FI =
I.getFrameIdx();
404 BuildMI(
MBB, Pos, dl,
TII.get(TargetOpcode::CFI_INSTRUCTION))
421 unsigned ScratchRegister = ARM::NoRegister;
422 for (
auto &
I : CSI) {
425 ScratchRegister = Reg;
432 CFAOffset += NumBytes;
449 if (RegInfo->hasStackRealignment(MF)) {
513 assert((
unsigned)NumBytes >= ArgRegsSaveSize &&
514 "ArgRegsSaveSize is included in NumBytes");
518 if (NumBytes - ArgRegsSaveSize != 0)
520 NumBytes - ArgRegsSaveSize, ARM::NoRegister,
541 unsigned ScratchRegister = ARM::NoRegister;
542 bool HasFP =
hasFP(MF);
546 ScratchRegister = Reg;
557 assert(ScratchRegister != ARM::NoRegister &&
558 "No scratch register to restore SP from FP!");
583 if (needPopSpecialFixUp(MF)) {
584 bool Done = emitPopSpecialFixUp(
MBB,
true);
586 assert(
Done &&
"Emission of the special fixup failed!?");
595 return emitPopSpecialFixUp(*TmpMBB,
false);
598bool Thumb1FrameLowering::needPopSpecialFixUp(
const MachineFunction &MF)
const {
606 if (CSI.getReg() == ARM::LR)
617 for (
auto Reg : GPRsNoLRSP.
set_bits()) {
620 if (PopFriendly.
test(Reg)) {
649 bool CanRestoreDirectly =
STI.hasV5TOps() && !ArgRegsSaveSize;
650 if (CanRestoreDirectly) {
652 CanRestoreDirectly = (
MBBI->getOpcode() == ARM::tBX_RET ||
653 MBBI->getOpcode() == ARM::tPOP_RET);
655 auto MBBI_prev =
MBBI;
657 assert(MBBI_prev->getOpcode() == ARM::tPOP);
659 if ((*
MBB.
succ_begin())->begin()->getOpcode() == ARM::tBX_RET)
662 CanRestoreDirectly =
false;
666 if (CanRestoreDirectly) {
667 if (!DoIt ||
MBBI->getOpcode() == ARM::tPOP_RET)
674 for (
auto MO:
MBBI->operands())
675 if (MO.isReg() && (MO.isImplicit() || MO.isDef()))
687 UsedRegs.addLiveOuts(
MBB);
693 for (
unsigned i = 0; CSRegs[i]; ++i)
694 UsedRegs.addReg(CSRegs[i]);
698 dl =
MBBI->getDebugLoc();
699 auto InstUpToMBBI =
MBB.
end();
700 while (InstUpToMBBI !=
MBBI)
703 UsedRegs.stepBackward(*--InstUpToMBBI);
709 unsigned TemporaryReg = 0;
711 TRI.getAllocatableSet(MF,
TRI.getRegClass(ARM::tGPRRegClassID));
713 assert(PopFriendly.
any() &&
"No allocatable pop-friendly register?!");
717 TRI.getAllocatableSet(MF,
TRI.getRegClass(ARM::hGPRRegClassID));
718 GPRsNoLRSP |= PopFriendly;
719 GPRsNoLRSP.
reset(ARM::LR);
720 GPRsNoLRSP.
reset(ARM::SP);
721 GPRsNoLRSP.
reset(ARM::PC);
728 bool UseLDRSP =
false;
730 auto PrevMBBI =
MBBI;
732 if (PrevMBBI->getOpcode() == ARM::tPOP) {
733 UsedRegs.stepBackward(*PrevMBBI);
743 if (!DoIt && !PopReg && !TemporaryReg)
746 assert((PopReg || TemporaryReg) &&
"Cannot get LR");
749 assert(PopReg &&
"Do not know how to get LR");
767 ArgRegsSaveSize + 4, ARM::NoRegister,
773 assert(!PopReg &&
"Unnecessary MOV is about to be inserted");
790 for (
auto MO:
MBBI->operands())
791 if (MO.isReg() && (MO.isImplicit() || MO.isDef()) &&
792 MO.getReg() != ARM::PC) {
794 if (!MO.isImplicit())
807 assert(PopReg &&
"Do not know how to get LR");
837 ARM::R0, ARM::R1, ARM::R2, ARM::R3, ARM::R4,
838 ARM::R5, ARM::R6, ARM::R7, ARM::LR};
841 std::set<Register> &LowRegs,
842 std::set<Register> &HighRegs) {
844 if (ARM::tGPRRegClass.
contains(Reg) || Reg == ARM::LR) {
846 }
else if (ARM::hGPRRegClass.
contains(Reg) && Reg != ARM::LR) {
847 HighRegs.insert(Reg);
854template <
typename It>
856 const std::set<Register> &RegSet) {
857 return std::find_if(OrderedStartIt, OrderedEndIt,
858 [&](
Register Reg) {
return RegSet.count(Reg); });
864 const std::set<Register> &RegsToSave,
865 const std::set<Register> &CopyRegs) {
870 std::set<Register> LowRegs, HighRegs;
874 if (!LowRegs.empty()) {
878 if (LowRegs.count(Reg)) {
879 bool isKill = !
MRI.isLiveIn(Reg);
880 if (isKill && !
MRI.isReserved(Reg))
918 if (HighRegs.count(*HiRegToSave)) {
919 bool isKill = !
MRI.isLiveIn(*HiRegToSave);
920 if (isKill && !
MRI.isReserved(*HiRegToSave))
954 const std::set<Register> &RegsToRestore,
955 const std::set<Register> &AvailableCopyRegs,
956 bool IsVarArg,
bool HasV5Ops) {
957 if (RegsToRestore.empty())
964 std::set<Register> LowRegs, HighRegs;
978 std::set<Register> CopyRegs = AvailableCopyRegs;
980 if (!HighRegs.empty() && CopyRegs.empty()) {
983 LowScratchReg = ARM::R0;
989 CopyRegs.insert(LowScratchReg);
993 assert(!CopyRegs.empty());
1026 if (LowScratchReg.
isValid()) {
1035 if (!LowRegs.empty()) {
1040 bool NeedsPop =
false;
1042 if (!LowRegs.count(Reg))
1045 if (Reg == ARM::LR) {
1047 MI->getOpcode() == ARM::TCRETURNri ||
1048 MI->getOpcode() == ARM::TCRETURNrinotr12)
1069 (*MIB).setDesc(
TII.get(ARM::tPOP_RET));
1100 bool NeedsFrameRecordPush =
hasFP(MF) && ARM::hGPRRegClass.contains(FPReg);
1102 std::set<Register> FrameRecord;
1103 std::set<Register> SpilledGPRs;
1106 if (NeedsFrameRecordPush && (Reg == FPReg || Reg == ARM::LR))
1107 FrameRecord.insert(Reg);
1109 SpilledGPRs.insert(Reg);
1117 std::set<Register> CopyRegs;
1119 if ((ARM::tGPRRegClass.
contains(Reg) || Reg == ARM::LR) &&
1121 CopyRegs.insert(Reg);
1122 for (
unsigned ArgReg : {ARM::R0, ARM::R1, ARM::R2, ARM::R3})
1124 CopyRegs.insert(ArgReg);
1147 bool NeedsFrameRecordPop =
hasFP(MF) && ARM::hGPRRegClass.contains(FPReg);
1149 std::set<Register> FrameRecord;
1150 std::set<Register> SpilledGPRs;
1153 if (NeedsFrameRecordPop && (Reg == FPReg || Reg == ARM::LR))
1154 FrameRecord.insert(Reg);
1156 SpilledGPRs.insert(Reg);
1159 I.setRestored(
false);
1165 std::set<Register> CopyRegs;
1166 std::set<Register> UnusedReturnRegs;
1168 if ((ARM::tGPRRegClass.
contains(Reg)) && !(
hasFP(MF) && Reg == FPReg))
1169 CopyRegs.insert(Reg);
1171 if (Terminator !=
MBB.
end() && Terminator->getOpcode() == ARM::tBX_RET) {
1172 UnusedReturnRegs.insert(ARM::R0);
1173 UnusedReturnRegs.insert(ARM::R1);
1174 UnusedReturnRegs.insert(ARM::R2);
1175 UnusedReturnRegs.insert(ARM::R3);
1176 for (
auto Op : Terminator->implicit_operands()) {
1178 UnusedReturnRegs.erase(
Op.getReg());
1181 CopyRegs.insert(UnusedReturnRegs.begin(), UnusedReturnRegs.end());
1189 assert((!SpilledGPRs.count(ARM::LR) || FrameRecord.empty()) &&
1190 "Can't insert pop after return sequence");
unsigned const MachineRegisterInfo * MRI
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
MachineBasicBlock MachineBasicBlock::iterator MBBI
This file implements the BitVector class.
const HexagonInstrInfo * TII
This file implements the LivePhysRegs utility for tracking liveness of physical registers.
unsigned const TargetRegisterInfo * TRI
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallVector class.
static void emitCallSPUpdate(MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI, const TargetInstrInfo &TII, const DebugLoc &dl, const ThumbRegisterInfo &MRI, int NumBytes, unsigned MIFlags=MachineInstr::NoFlags)
static const SmallVector< Register > OrderedCopyRegs
static const SmallVector< Register > OrderedLowRegs
static void splitLowAndHighRegs(const std::set< Register > &Regs, std::set< Register > &LowRegs, std::set< Register > &HighRegs)
It getNextOrderedReg(It OrderedStartIt, It OrderedEndIt, const std::set< Register > &RegSet)
static void emitPrologueEpilogueSPUpdate(MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI, const TargetInstrInfo &TII, const DebugLoc &dl, const ThumbRegisterInfo &MRI, int NumBytes, unsigned ScratchReg, unsigned MIFlags)
static const SmallVector< Register > OrderedHighRegs
static void popRegsFromStack(MachineBasicBlock &MBB, MachineBasicBlock::iterator &MI, const TargetInstrInfo &TII, const std::set< Register > &RegsToRestore, const std::set< Register > &AvailableCopyRegs, bool IsVarArg, bool HasV5Ops)
static void pushRegsToStack(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, const TargetInstrInfo &TII, const std::set< Register > &RegsToSave, const std::set< Register > &CopyRegs)
static void findTemporariesForLR(const BitVector &GPRsNoLRSP, const BitVector &PopFriendly, const LiveRegUnits &UsedRegs, unsigned &PopReg, unsigned &TmpReg, MachineRegisterInfo &MRI)
static bool contains(SmallPtrSetImpl< ConstantExpr * > &Cache, ConstantExpr *Expr, Constant *C)
static const unsigned FramePtr
bool hasBasePointer(const MachineFunction &MF) const
Register getFrameRegister(const MachineFunction &MF) const override
Register getBaseRegister() const
bool hasFP(const MachineFunction &MF) const override
hasFP - Return true if the specified function should have a dedicated frame pointer register.
ARMFunctionInfo - This class is derived from MachineFunctionInfo and contains private ARM-specific in...
void setDPRCalleeSavedAreaSize(unsigned s)
bool hasStackFrame() const
unsigned getGPRCalleeSavedArea1Size() const
void setGPRCalleeSavedArea2Size(unsigned s)
void setDPRCalleeSavedAreaOffset(unsigned o)
void setFramePtrSpillOffset(unsigned o)
unsigned getGPRCalleeSavedArea2Size() const
void setGPRCalleeSavedArea1Size(unsigned s)
bool isCmseNSEntryFunction() const
unsigned getDPRCalleeSavedAreaSize() const
unsigned getFramePtrSpillOffset() const
bool shouldRestoreSPFromFP() const
void setFrameRecordSavedAreaSize(unsigned s)
unsigned getArgRegsSaveSize() const
void setGPRCalleeSavedArea2Offset(unsigned o)
unsigned getFrameRecordSavedAreaSize() const
void setGPRCalleeSavedArea1Offset(unsigned o)
void setShouldRestoreSPFromFP(bool s)
const ARMBaseInstrInfo * getInstrInfo() const override
const ARMBaseRegisterInfo * getRegisterInfo() const override
bool splitFramePushPop(const MachineFunction &MF) const
Returns true if the frame setup is split into two separate pushes (first r0-r7,lr then r8-r11),...
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
bool empty() const
empty - Check if the array is empty.
bool test(unsigned Idx) const
int find_first() const
find_first - Returns the index of the first set bit, -1 if none of the bits are set.
bool any() const
any - Returns true if any bit is set.
iterator_range< const_set_bits_iterator > set_bits() const
The CalleeSavedInfo class tracks the information need to locate where a callee saved register is in t...
This class represents an Operation in the Expression.
A set of register units used to track register liveness.
bool available(MCPhysReg Reg) const
Returns true if no part of physical register Reg is live.
static MCCFIInstruction createDefCfaRegister(MCSymbol *L, unsigned Register, SMLoc Loc={})
.cfi_def_cfa_register modifies a rule for computing CFA.
static MCCFIInstruction cfiDefCfa(MCSymbol *L, unsigned Register, int64_t Offset, SMLoc Loc={})
.cfi_def_cfa defines a rule for computing CFA as: take address from Register and add Offset to it.
static MCCFIInstruction createOffset(MCSymbol *L, unsigned Register, int64_t Offset, SMLoc Loc={})
.cfi_offset Previous value of Register is saved at offset Offset from CFA.
static MCCFIInstruction cfiDefCfaOffset(MCSymbol *L, int64_t Offset, SMLoc Loc={})
.cfi_def_cfa_offset modifies a rule for computing CFA.
const MCRegisterInfo * getRegisterInfo() const
MCRegisterInfo base class - We assume that the target defines a static array of MCRegisterDesc object...
instr_iterator insert(instr_iterator I, MachineInstr *M)
Insert MI into the instruction list before I, possibly inside a bundle.
succ_iterator succ_begin()
iterator getFirstTerminator()
Returns an iterator to the first terminator instruction of this basic block.
unsigned succ_size() const
void addLiveIn(MCRegister PhysReg, LaneBitmask LaneMask=LaneBitmask::getAll())
Adds the specified register as a live in.
const MachineFunction * getParent() const
Return the MachineFunction containing this basic block.
instr_iterator erase(instr_iterator I)
Remove an instruction from the instruction list and delete it.
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted.
bool hasVarSizedObjects() const
This method may be called any time after instruction selection is complete to determine if the stack ...
uint64_t getStackSize() const
Return the number of bytes that must be allocated to hold all of the fixed size frame objects.
Align getMaxAlign() const
Return the alignment in bytes that this function must be aligned to, which is greater than the defaul...
uint64_t getMaxCallFrameSize() const
Return the maximum size of a call frame that must be allocated for an outgoing function call.
int64_t getOffsetAdjustment() const
Return the correction for frame offsets.
const std::vector< CalleeSavedInfo > & getCalleeSavedInfo() const
Returns a reference to call saved info vector for the current function.
int64_t getObjectOffset(int ObjectIdx) const
Return the assigned stack offset of the specified object from the incoming stack pointer.
void setStackSize(uint64_t Size)
Set the size of the stack.
void setOffsetAdjustment(int64_t Adj)
Set the correction for frame offsets.
MachineFunctionProperties & reset(Property P)
unsigned addFrameInst(const MCCFIInstruction &Inst)
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
MachineFrameInfo & getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
void deleteMachineInstr(MachineInstr *MI)
DeleteMachineInstr - Delete the given MachineInstr.
MCContext & getContext() const
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
Ty * getInfo()
getInfo - Keep track of various per-function pieces of information for backends that would like to do...
const MachineFunctionProperties & getProperties() const
Get the function properties.
const MachineInstrBuilder & addCFIIndex(unsigned CFIIndex) const
const MachineInstrBuilder & setMIFlag(MachineInstr::MIFlag Flag) const
const MachineInstrBuilder & addImm(int64_t Val) const
Add a new immediate operand.
const MachineInstrBuilder & add(const MachineOperand &MO) const
const MachineInstrBuilder & addReg(Register RegNo, unsigned flags=0, unsigned SubReg=0) const
Add a new virtual register operand.
const MachineInstrBuilder & setMIFlags(unsigned Flags) const
const MachineInstrBuilder & copyImplicitOps(const MachineInstr &OtherMI) const
Copy all the implicit operands from OtherMI onto this one.
MachineInstr * getInstr() const
If conversion operators fail, use this method to get the MachineInstr explicitly.
const MachineInstrBuilder & addDef(Register RegNo, unsigned Flags=0, unsigned SubReg=0) const
Add a virtual register definition operand.
Representation of each machine instruction.
unsigned getOpcode() const
Returns the opcode of this MachineInstr.
const DebugLoc & getDebugLoc() const
Returns the debug location id of this MachineInstr.
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
bool isLiveIn(Register Reg) const
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
Wrapper class representing virtual and physical registers.
constexpr bool isValid() const
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Align getStackAlign() const
getStackAlignment - This method returns the number of bytes to which the stack pointer must be aligne...
TargetInstrInfo - Interface to description of machine instruction set.
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
virtual const TargetRegisterInfo * getRegisterInfo() const
getRegisterInfo - If register information is available, return it.
MachineBasicBlock::iterator eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB, MachineBasicBlock::iterator MI) const override
This method is called during prolog/epilog code insertion to eliminate call frame setup and destroy p...
Thumb1FrameLowering(const ARMSubtarget &sti)
void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override
emitProlog/emitEpilog - These methods insert prolog and epilog code into the function.
void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override
bool canUseAsEpilogue(const MachineBasicBlock &MBB) const override
Check whether or not the given MBB can be used as a epilogue for the target.
bool hasReservedCallFrame(const MachineFunction &MF) const override
hasReservedCallFrame - Under normal circumstances, when a frame pointer is not required,...
bool restoreCalleeSavedRegisters(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, MutableArrayRef< CalleeSavedInfo > CSI, const TargetRegisterInfo *TRI) const override
restoreCalleeSavedRegisters - Issues instruction(s) to restore all callee saved registers and returns...
bool spillCalleeSavedRegisters(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, ArrayRef< CalleeSavedInfo > CSI, const TargetRegisterInfo *TRI) const override
spillCalleeSavedRegisters - Issues instruction(s) to spill all callee saved registers and returns tru...
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ Define
Register definition.
@ Kill
The last use of a register.
This is an optimization pass for GlobalISel generic memory operations.
MachineInstrBuilder BuildMI(MachineFunction &MF, const MIMetadata &MIMD, const MCInstrDesc &MCID)
Builder interface. Specify how to create the initial instruction itself.
static std::array< MachineOperand, 2 > predOps(ARMCC::CondCodes Pred, unsigned PredReg=0)
Get the operands corresponding to the given Pred value.
bool tryFoldSPUpdateIntoPushPop(const ARMSubtarget &Subtarget, MachineFunction &MF, MachineInstr *MI, unsigned NumBytes)
Tries to add registers to the reglist of a given base-updating push/pop instruction to adjust the sta...
static bool isARMLowRegister(unsigned Reg)
isARMLowRegister - Returns true if the register is a low register (r0-r7).
auto reverse(ContainerTy &&C)
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
unsigned getDefRegState(bool B)
unsigned getKillRegState(bool B)
void emitThumbRegPlusImmediate(MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI, const DebugLoc &dl, Register DestReg, Register BaseReg, int NumBytes, const TargetInstrInfo &TII, const ARMBaseRegisterInfo &MRI, unsigned MIFlags=0)
emitThumbRegPlusImmediate - Emits a series of instructions to materialize a destreg = basereg + immed...
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
unsigned Log2(Align A)
Returns the log2 of the alignment.