MachineFrameInfo.h revision 263312
1//===-- CodeGen/MachineFrameInfo.h - Abstract Stack Frame Rep. --*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// The file defines the MachineFrameInfo class. 11// 12//===----------------------------------------------------------------------===// 13 14#ifndef LLVM_CODEGEN_MACHINEFRAMEINFO_H 15#define LLVM_CODEGEN_MACHINEFRAMEINFO_H 16 17#include "llvm/ADT/SmallVector.h" 18#include "llvm/Support/DataTypes.h" 19#include <cassert> 20#include <vector> 21 22namespace llvm { 23class raw_ostream; 24class DataLayout; 25class TargetRegisterClass; 26class Type; 27class MachineFunction; 28class MachineBasicBlock; 29class TargetFrameLowering; 30class TargetMachine; 31class BitVector; 32class Value; 33class AllocaInst; 34 35/// The CalleeSavedInfo class tracks the information need to locate where a 36/// callee saved register is in the current frame. 37class CalleeSavedInfo { 38 unsigned Reg; 39 int FrameIdx; 40 41public: 42 explicit CalleeSavedInfo(unsigned R, int FI = 0) 43 : Reg(R), FrameIdx(FI) {} 44 45 // Accessors. 46 unsigned getReg() const { return Reg; } 47 int getFrameIdx() const { return FrameIdx; } 48 void setFrameIdx(int FI) { FrameIdx = FI; } 49}; 50 51/// The MachineFrameInfo class represents an abstract stack frame until 52/// prolog/epilog code is inserted. This class is key to allowing stack frame 53/// representation optimizations, such as frame pointer elimination. It also 54/// allows more mundane (but still important) optimizations, such as reordering 55/// of abstract objects on the stack frame. 56/// 57/// To support this, the class assigns unique integer identifiers to stack 58/// objects requested clients. These identifiers are negative integers for 59/// fixed stack objects (such as arguments passed on the stack) or nonnegative 60/// for objects that may be reordered. Instructions which refer to stack 61/// objects use a special MO_FrameIndex operand to represent these frame 62/// indexes. 63/// 64/// Because this class keeps track of all references to the stack frame, it 65/// knows when a variable sized object is allocated on the stack. This is the 66/// sole condition which prevents frame pointer elimination, which is an 67/// important optimization on register-poor architectures. Because original 68/// variable sized alloca's in the source program are the only source of 69/// variable sized stack objects, it is safe to decide whether there will be 70/// any variable sized objects before all stack objects are known (for 71/// example, register allocator spill code never needs variable sized 72/// objects). 73/// 74/// When prolog/epilog code emission is performed, the final stack frame is 75/// built and the machine instructions are modified to refer to the actual 76/// stack offsets of the object, eliminating all MO_FrameIndex operands from 77/// the program. 78/// 79/// @brief Abstract Stack Frame Information 80class MachineFrameInfo { 81 82 // StackObject - Represent a single object allocated on the stack. 83 struct StackObject { 84 // SPOffset - The offset of this object from the stack pointer on entry to 85 // the function. This field has no meaning for a variable sized element. 86 int64_t SPOffset; 87 88 // The size of this object on the stack. 0 means a variable sized object, 89 // ~0ULL means a dead object. 90 uint64_t Size; 91 92 // Alignment - The required alignment of this stack slot. 93 unsigned Alignment; 94 95 // isImmutable - If true, the value of the stack object is set before 96 // entering the function and is not modified inside the function. By 97 // default, fixed objects are immutable unless marked otherwise. 98 bool isImmutable; 99 100 // isSpillSlot - If true the stack object is used as spill slot. It 101 // cannot alias any other memory objects. 102 bool isSpillSlot; 103 104 // MayNeedSP - If true the stack object triggered the creation of the stack 105 // protector. We should allocate this object right after the stack 106 // protector. 107 bool MayNeedSP; 108 109 /// Alloca - If this stack object is originated from an Alloca instruction 110 /// this value saves the original IR allocation. Can be NULL. 111 const AllocaInst *Alloca; 112 113 // PreAllocated - If true, the object was mapped into the local frame 114 // block and doesn't need additional handling for allocation beyond that. 115 bool PreAllocated; 116 117 StackObject(uint64_t Sz, unsigned Al, int64_t SP, bool IM, 118 bool isSS, bool NSP, const AllocaInst *Val) 119 : SPOffset(SP), Size(Sz), Alignment(Al), isImmutable(IM), 120 isSpillSlot(isSS), MayNeedSP(NSP), Alloca(Val), PreAllocated(false) {} 121 }; 122 123 const TargetMachine &TM; 124 125 /// Objects - The list of stack objects allocated... 126 /// 127 std::vector<StackObject> Objects; 128 129 /// NumFixedObjects - This contains the number of fixed objects contained on 130 /// the stack. Because fixed objects are stored at a negative index in the 131 /// Objects list, this is also the index to the 0th object in the list. 132 /// 133 unsigned NumFixedObjects; 134 135 /// HasVarSizedObjects - This boolean keeps track of whether any variable 136 /// sized objects have been allocated yet. 137 /// 138 bool HasVarSizedObjects; 139 140 /// FrameAddressTaken - This boolean keeps track of whether there is a call 141 /// to builtin \@llvm.frameaddress. 142 bool FrameAddressTaken; 143 144 /// ReturnAddressTaken - This boolean keeps track of whether there is a call 145 /// to builtin \@llvm.returnaddress. 146 bool ReturnAddressTaken; 147 148 /// StackSize - The prolog/epilog code inserter calculates the final stack 149 /// offsets for all of the fixed size objects, updating the Objects list 150 /// above. It then updates StackSize to contain the number of bytes that need 151 /// to be allocated on entry to the function. 152 /// 153 uint64_t StackSize; 154 155 /// OffsetAdjustment - The amount that a frame offset needs to be adjusted to 156 /// have the actual offset from the stack/frame pointer. The exact usage of 157 /// this is target-dependent, but it is typically used to adjust between 158 /// SP-relative and FP-relative offsets. E.G., if objects are accessed via 159 /// SP then OffsetAdjustment is zero; if FP is used, OffsetAdjustment is set 160 /// to the distance between the initial SP and the value in FP. For many 161 /// targets, this value is only used when generating debug info (via 162 /// TargetRegisterInfo::getFrameIndexOffset); when generating code, the 163 /// corresponding adjustments are performed directly. 164 int OffsetAdjustment; 165 166 /// MaxAlignment - The prolog/epilog code inserter may process objects 167 /// that require greater alignment than the default alignment the target 168 /// provides. To handle this, MaxAlignment is set to the maximum alignment 169 /// needed by the objects on the current frame. If this is greater than the 170 /// native alignment maintained by the compiler, dynamic alignment code will 171 /// be needed. 172 /// 173 unsigned MaxAlignment; 174 175 /// AdjustsStack - Set to true if this function adjusts the stack -- e.g., 176 /// when calling another function. This is only valid during and after 177 /// prolog/epilog code insertion. 178 bool AdjustsStack; 179 180 /// HasCalls - Set to true if this function has any function calls. 181 bool HasCalls; 182 183 /// StackProtectorIdx - The frame index for the stack protector. 184 int StackProtectorIdx; 185 186 /// FunctionContextIdx - The frame index for the function context. Used for 187 /// SjLj exceptions. 188 int FunctionContextIdx; 189 190 /// MaxCallFrameSize - This contains the size of the largest call frame if the 191 /// target uses frame setup/destroy pseudo instructions (as defined in the 192 /// TargetFrameInfo class). This information is important for frame pointer 193 /// elimination. If is only valid during and after prolog/epilog code 194 /// insertion. 195 /// 196 unsigned MaxCallFrameSize; 197 198 /// CSInfo - The prolog/epilog code inserter fills in this vector with each 199 /// callee saved register saved in the frame. Beyond its use by the prolog/ 200 /// epilog code inserter, this data used for debug info and exception 201 /// handling. 202 std::vector<CalleeSavedInfo> CSInfo; 203 204 /// CSIValid - Has CSInfo been set yet? 205 bool CSIValid; 206 207 /// LocalFrameObjects - References to frame indices which are mapped 208 /// into the local frame allocation block. <FrameIdx, LocalOffset> 209 SmallVector<std::pair<int, int64_t>, 32> LocalFrameObjects; 210 211 /// LocalFrameSize - Size of the pre-allocated local frame block. 212 int64_t LocalFrameSize; 213 214 /// Required alignment of the local object blob, which is the strictest 215 /// alignment of any object in it. 216 unsigned LocalFrameMaxAlign; 217 218 /// Whether the local object blob needs to be allocated together. If not, 219 /// PEI should ignore the isPreAllocated flags on the stack objects and 220 /// just allocate them normally. 221 bool UseLocalStackAllocationBlock; 222 223 /// Whether the "realign-stack" option is on. 224 bool RealignOption; 225 226 /// True if the function includes inline assembly that adjusts the stack 227 /// pointer. 228 bool HasInlineAsmWithSPAdjust; 229 230 const TargetFrameLowering *getFrameLowering() const; 231public: 232 explicit MachineFrameInfo(const TargetMachine &TM, bool RealignOpt) 233 : TM(TM), RealignOption(RealignOpt) { 234 StackSize = NumFixedObjects = OffsetAdjustment = MaxAlignment = 0; 235 HasVarSizedObjects = false; 236 FrameAddressTaken = false; 237 ReturnAddressTaken = false; 238 AdjustsStack = false; 239 HasCalls = false; 240 StackProtectorIdx = -1; 241 FunctionContextIdx = -1; 242 MaxCallFrameSize = 0; 243 CSIValid = false; 244 LocalFrameSize = 0; 245 LocalFrameMaxAlign = 0; 246 UseLocalStackAllocationBlock = false; 247 HasInlineAsmWithSPAdjust = false; 248 } 249 250 /// hasStackObjects - Return true if there are any stack objects in this 251 /// function. 252 /// 253 bool hasStackObjects() const { return !Objects.empty(); } 254 255 /// hasVarSizedObjects - This method may be called any time after instruction 256 /// selection is complete to determine if the stack frame for this function 257 /// contains any variable sized objects. 258 /// 259 bool hasVarSizedObjects() const { return HasVarSizedObjects; } 260 261 /// getStackProtectorIndex/setStackProtectorIndex - Return the index for the 262 /// stack protector object. 263 /// 264 int getStackProtectorIndex() const { return StackProtectorIdx; } 265 void setStackProtectorIndex(int I) { StackProtectorIdx = I; } 266 267 /// getFunctionContextIndex/setFunctionContextIndex - Return the index for the 268 /// function context object. This object is used for SjLj exceptions. 269 int getFunctionContextIndex() const { return FunctionContextIdx; } 270 void setFunctionContextIndex(int I) { FunctionContextIdx = I; } 271 272 /// isFrameAddressTaken - This method may be called any time after instruction 273 /// selection is complete to determine if there is a call to 274 /// \@llvm.frameaddress in this function. 275 bool isFrameAddressTaken() const { return FrameAddressTaken; } 276 void setFrameAddressIsTaken(bool T) { FrameAddressTaken = T; } 277 278 /// isReturnAddressTaken - This method may be called any time after 279 /// instruction selection is complete to determine if there is a call to 280 /// \@llvm.returnaddress in this function. 281 bool isReturnAddressTaken() const { return ReturnAddressTaken; } 282 void setReturnAddressIsTaken(bool s) { ReturnAddressTaken = s; } 283 284 /// getObjectIndexBegin - Return the minimum frame object index. 285 /// 286 int getObjectIndexBegin() const { return -NumFixedObjects; } 287 288 /// getObjectIndexEnd - Return one past the maximum frame object index. 289 /// 290 int getObjectIndexEnd() const { return (int)Objects.size()-NumFixedObjects; } 291 292 /// getNumFixedObjects - Return the number of fixed objects. 293 unsigned getNumFixedObjects() const { return NumFixedObjects; } 294 295 /// getNumObjects - Return the number of objects. 296 /// 297 unsigned getNumObjects() const { return Objects.size(); } 298 299 /// mapLocalFrameObject - Map a frame index into the local object block 300 void mapLocalFrameObject(int ObjectIndex, int64_t Offset) { 301 LocalFrameObjects.push_back(std::pair<int, int64_t>(ObjectIndex, Offset)); 302 Objects[ObjectIndex + NumFixedObjects].PreAllocated = true; 303 } 304 305 /// getLocalFrameObjectMap - Get the local offset mapping for a for an object 306 std::pair<int, int64_t> getLocalFrameObjectMap(int i) { 307 assert (i >= 0 && (unsigned)i < LocalFrameObjects.size() && 308 "Invalid local object reference!"); 309 return LocalFrameObjects[i]; 310 } 311 312 /// getLocalFrameObjectCount - Return the number of objects allocated into 313 /// the local object block. 314 int64_t getLocalFrameObjectCount() { return LocalFrameObjects.size(); } 315 316 /// setLocalFrameSize - Set the size of the local object blob. 317 void setLocalFrameSize(int64_t sz) { LocalFrameSize = sz; } 318 319 /// getLocalFrameSize - Get the size of the local object blob. 320 int64_t getLocalFrameSize() const { return LocalFrameSize; } 321 322 /// setLocalFrameMaxAlign - Required alignment of the local object blob, 323 /// which is the strictest alignment of any object in it. 324 void setLocalFrameMaxAlign(unsigned Align) { LocalFrameMaxAlign = Align; } 325 326 /// getLocalFrameMaxAlign - Return the required alignment of the local 327 /// object blob. 328 unsigned getLocalFrameMaxAlign() const { return LocalFrameMaxAlign; } 329 330 /// getUseLocalStackAllocationBlock - Get whether the local allocation blob 331 /// should be allocated together or let PEI allocate the locals in it 332 /// directly. 333 bool getUseLocalStackAllocationBlock() {return UseLocalStackAllocationBlock;} 334 335 /// setUseLocalStackAllocationBlock - Set whether the local allocation blob 336 /// should be allocated together or let PEI allocate the locals in it 337 /// directly. 338 void setUseLocalStackAllocationBlock(bool v) { 339 UseLocalStackAllocationBlock = v; 340 } 341 342 /// isObjectPreAllocated - Return true if the object was pre-allocated into 343 /// the local block. 344 bool isObjectPreAllocated(int ObjectIdx) const { 345 assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() && 346 "Invalid Object Idx!"); 347 return Objects[ObjectIdx+NumFixedObjects].PreAllocated; 348 } 349 350 /// getObjectSize - Return the size of the specified object. 351 /// 352 int64_t getObjectSize(int ObjectIdx) const { 353 assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() && 354 "Invalid Object Idx!"); 355 return Objects[ObjectIdx+NumFixedObjects].Size; 356 } 357 358 /// setObjectSize - Change the size of the specified stack object. 359 void setObjectSize(int ObjectIdx, int64_t Size) { 360 assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() && 361 "Invalid Object Idx!"); 362 Objects[ObjectIdx+NumFixedObjects].Size = Size; 363 } 364 365 /// getObjectAlignment - Return the alignment of the specified stack object. 366 unsigned getObjectAlignment(int ObjectIdx) const { 367 assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() && 368 "Invalid Object Idx!"); 369 return Objects[ObjectIdx+NumFixedObjects].Alignment; 370 } 371 372 /// setObjectAlignment - Change the alignment of the specified stack object. 373 void setObjectAlignment(int ObjectIdx, unsigned Align) { 374 assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() && 375 "Invalid Object Idx!"); 376 Objects[ObjectIdx+NumFixedObjects].Alignment = Align; 377 ensureMaxAlignment(Align); 378 } 379 380 /// getObjectAllocation - Return the underlying Alloca of the specified 381 /// stack object if it exists. Returns 0 if none exists. 382 const AllocaInst* getObjectAllocation(int ObjectIdx) const { 383 assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() && 384 "Invalid Object Idx!"); 385 return Objects[ObjectIdx+NumFixedObjects].Alloca; 386 } 387 388 /// NeedsStackProtector - Returns true if the object may need stack 389 /// protectors. 390 bool MayNeedStackProtector(int ObjectIdx) const { 391 assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() && 392 "Invalid Object Idx!"); 393 return Objects[ObjectIdx+NumFixedObjects].MayNeedSP; 394 } 395 396 /// getObjectOffset - Return the assigned stack offset of the specified object 397 /// from the incoming stack pointer. 398 /// 399 int64_t getObjectOffset(int ObjectIdx) const { 400 assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() && 401 "Invalid Object Idx!"); 402 assert(!isDeadObjectIndex(ObjectIdx) && 403 "Getting frame offset for a dead object?"); 404 return Objects[ObjectIdx+NumFixedObjects].SPOffset; 405 } 406 407 /// setObjectOffset - Set the stack frame offset of the specified object. The 408 /// offset is relative to the stack pointer on entry to the function. 409 /// 410 void setObjectOffset(int ObjectIdx, int64_t SPOffset) { 411 assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() && 412 "Invalid Object Idx!"); 413 assert(!isDeadObjectIndex(ObjectIdx) && 414 "Setting frame offset for a dead object?"); 415 Objects[ObjectIdx+NumFixedObjects].SPOffset = SPOffset; 416 } 417 418 /// getStackSize - Return the number of bytes that must be allocated to hold 419 /// all of the fixed size frame objects. This is only valid after 420 /// Prolog/Epilog code insertion has finalized the stack frame layout. 421 /// 422 uint64_t getStackSize() const { return StackSize; } 423 424 /// setStackSize - Set the size of the stack... 425 /// 426 void setStackSize(uint64_t Size) { StackSize = Size; } 427 428 /// Estimate and return the size of the stack frame. 429 unsigned estimateStackSize(const MachineFunction &MF) const; 430 431 /// getOffsetAdjustment - Return the correction for frame offsets. 432 /// 433 int getOffsetAdjustment() const { return OffsetAdjustment; } 434 435 /// setOffsetAdjustment - Set the correction for frame offsets. 436 /// 437 void setOffsetAdjustment(int Adj) { OffsetAdjustment = Adj; } 438 439 /// getMaxAlignment - Return the alignment in bytes that this function must be 440 /// aligned to, which is greater than the default stack alignment provided by 441 /// the target. 442 /// 443 unsigned getMaxAlignment() const { return MaxAlignment; } 444 445 /// ensureMaxAlignment - Make sure the function is at least Align bytes 446 /// aligned. 447 void ensureMaxAlignment(unsigned Align); 448 449 /// AdjustsStack - Return true if this function adjusts the stack -- e.g., 450 /// when calling another function. This is only valid during and after 451 /// prolog/epilog code insertion. 452 bool adjustsStack() const { return AdjustsStack; } 453 void setAdjustsStack(bool V) { AdjustsStack = V; } 454 455 /// hasCalls - Return true if the current function has any function calls. 456 bool hasCalls() const { return HasCalls; } 457 void setHasCalls(bool V) { HasCalls = V; } 458 459 /// Returns true if the function contains any stack-adjusting inline assembly. 460 bool hasInlineAsmWithSPAdjust() const { return HasInlineAsmWithSPAdjust; } 461 void setHasInlineAsmWithSPAdjust(bool B) { HasInlineAsmWithSPAdjust = B; } 462 463 /// getMaxCallFrameSize - Return the maximum size of a call frame that must be 464 /// allocated for an outgoing function call. This is only available if 465 /// CallFrameSetup/Destroy pseudo instructions are used by the target, and 466 /// then only during or after prolog/epilog code insertion. 467 /// 468 unsigned getMaxCallFrameSize() const { return MaxCallFrameSize; } 469 void setMaxCallFrameSize(unsigned S) { MaxCallFrameSize = S; } 470 471 /// CreateFixedObject - Create a new object at a fixed location on the stack. 472 /// All fixed objects should be created before other objects are created for 473 /// efficiency. By default, fixed objects are immutable. This returns an 474 /// index with a negative value. 475 /// 476 int CreateFixedObject(uint64_t Size, int64_t SPOffset, bool Immutable); 477 478 479 /// isFixedObjectIndex - Returns true if the specified index corresponds to a 480 /// fixed stack object. 481 bool isFixedObjectIndex(int ObjectIdx) const { 482 return ObjectIdx < 0 && (ObjectIdx >= -(int)NumFixedObjects); 483 } 484 485 /// isImmutableObjectIndex - Returns true if the specified index corresponds 486 /// to an immutable object. 487 bool isImmutableObjectIndex(int ObjectIdx) const { 488 assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() && 489 "Invalid Object Idx!"); 490 return Objects[ObjectIdx+NumFixedObjects].isImmutable; 491 } 492 493 /// isSpillSlotObjectIndex - Returns true if the specified index corresponds 494 /// to a spill slot.. 495 bool isSpillSlotObjectIndex(int ObjectIdx) const { 496 assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() && 497 "Invalid Object Idx!"); 498 return Objects[ObjectIdx+NumFixedObjects].isSpillSlot; 499 } 500 501 /// isDeadObjectIndex - Returns true if the specified index corresponds to 502 /// a dead object. 503 bool isDeadObjectIndex(int ObjectIdx) const { 504 assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() && 505 "Invalid Object Idx!"); 506 return Objects[ObjectIdx+NumFixedObjects].Size == ~0ULL; 507 } 508 509 /// CreateStackObject - Create a new statically sized stack object, returning 510 /// a nonnegative identifier to represent it. 511 /// 512 int CreateStackObject(uint64_t Size, unsigned Alignment, bool isSS, 513 bool MayNeedSP = false, const AllocaInst *Alloca = 0); 514 515 /// CreateSpillStackObject - Create a new statically sized stack object that 516 /// represents a spill slot, returning a nonnegative identifier to represent 517 /// it. 518 /// 519 int CreateSpillStackObject(uint64_t Size, unsigned Alignment); 520 521 /// RemoveStackObject - Remove or mark dead a statically sized stack object. 522 /// 523 void RemoveStackObject(int ObjectIdx) { 524 // Mark it dead. 525 Objects[ObjectIdx+NumFixedObjects].Size = ~0ULL; 526 } 527 528 /// CreateVariableSizedObject - Notify the MachineFrameInfo object that a 529 /// variable sized object has been created. This must be created whenever a 530 /// variable sized object is created, whether or not the index returned is 531 /// actually used. 532 /// 533 int CreateVariableSizedObject(unsigned Alignment, const AllocaInst *Alloca); 534 535 /// getCalleeSavedInfo - Returns a reference to call saved info vector for the 536 /// current function. 537 const std::vector<CalleeSavedInfo> &getCalleeSavedInfo() const { 538 return CSInfo; 539 } 540 541 /// setCalleeSavedInfo - Used by prolog/epilog inserter to set the function's 542 /// callee saved information. 543 void setCalleeSavedInfo(const std::vector<CalleeSavedInfo> &CSI) { 544 CSInfo = CSI; 545 } 546 547 /// isCalleeSavedInfoValid - Has the callee saved info been calculated yet? 548 bool isCalleeSavedInfoValid() const { return CSIValid; } 549 550 void setCalleeSavedInfoValid(bool v) { CSIValid = v; } 551 552 /// getPristineRegs - Return a set of physical registers that are pristine on 553 /// entry to the MBB. 554 /// 555 /// Pristine registers hold a value that is useless to the current function, 556 /// but that must be preserved - they are callee saved registers that have not 557 /// been saved yet. 558 /// 559 /// Before the PrologueEpilogueInserter has placed the CSR spill code, this 560 /// method always returns an empty set. 561 BitVector getPristineRegs(const MachineBasicBlock *MBB) const; 562 563 /// print - Used by the MachineFunction printer to print information about 564 /// stack objects. Implemented in MachineFunction.cpp 565 /// 566 void print(const MachineFunction &MF, raw_ostream &OS) const; 567 568 /// dump - Print the function to stderr. 569 void dump(const MachineFunction &MF) const; 570}; 571 572} // End llvm namespace 573 574#endif 575