MachineFrameInfo.h revision 355940
1101776Stjr//===-- CodeGen/MachineFrameInfo.h - Abstract Stack Frame Rep. --*- C++ -*-===// 2132491Stjr// 3101776Stjr// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4101776Stjr// See https://llvm.org/LICENSE.txt for license information. 5227753Stheraven// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6227753Stheraven// 7227753Stheraven//===----------------------------------------------------------------------===// 8227753Stheraven// 9227753Stheraven// The file defines the MachineFrameInfo class. 10101776Stjr// 11101776Stjr//===----------------------------------------------------------------------===// 12101776Stjr 13101776Stjr#ifndef LLVM_CODEGEN_MACHINEFRAMEINFO_H 14101776Stjr#define LLVM_CODEGEN_MACHINEFRAMEINFO_H 15101776Stjr 16101776Stjr#include "llvm/ADT/SmallVector.h" 17101776Stjr#include "llvm/Support/DataTypes.h" 18101776Stjr#include <cassert> 19101776Stjr#include <vector> 20101776Stjr 21101776Stjrnamespace llvm { 22101776Stjrclass raw_ostream; 23101776Stjrclass MachineFunction; 24101776Stjrclass MachineBasicBlock; 25101776Stjrclass BitVector; 26101776Stjrclass AllocaInst; 27101776Stjr 28101776Stjr/// The CalleeSavedInfo class tracks the information need to locate where a 29101776Stjr/// callee saved register is in the current frame. 30101776Stjr/// Callee saved reg can also be saved to a different register rather than 31101776Stjr/// on the stack by setting DstReg instead of FrameIdx. 32101776Stjrclass CalleeSavedInfo { 33101776Stjr unsigned Reg; 34101776Stjr union { 35101776Stjr int FrameIdx; 36101776Stjr unsigned DstReg; 37132497Stjr }; 38101776Stjr /// Flag indicating whether the register is actually restored in the epilog. 39101776Stjr /// In most cases, if a register is saved, it is also restored. There are 40101776Stjr /// some situations, though, when this is not the case. For example, the 41132491Stjr /// LR register on ARM is usually saved, but on exit from the function its 42101776Stjr /// saved value may be loaded directly into PC. Since liveness tracking of 43101776Stjr /// physical registers treats callee-saved registers are live outside of 44132491Stjr /// the function, LR would be treated as live-on-exit, even though in these 45101776Stjr /// scenarios it is not. This flag is added to indicate that the saved 46101776Stjr /// register described by this object is not restored in the epilog. 47227753Stheraven /// The long-term solution is to model the liveness of callee-saved registers 48101776Stjr /// by implicit uses on the return instructions, however, the required 49132491Stjr /// changes in the ARM backend would be quite extensive. 50132491Stjr bool Restored; 51132491Stjr /// Flag indicating whether the register is spilled to stack or another 52132491Stjr /// register. 53187302Srdivacky bool SpilledToReg; 54227753Stheraven 55227753Stheravenpublic: 56101776Stjr explicit CalleeSavedInfo(unsigned R, int FI = 0) 57103678Stjr : Reg(R), FrameIdx(FI), Restored(true), SpilledToReg(false) {} 58103678Stjr 59132491Stjr // Accessors. 60132491Stjr unsigned getReg() const { return Reg; } 61132491Stjr int getFrameIdx() const { return FrameIdx; } 62132491Stjr unsigned getDstReg() const { return DstReg; } 63132491Stjr void setFrameIdx(int FI) { 64234536Sdas FrameIdx = FI; 65132491Stjr SpilledToReg = false; 66227753Stheraven } 67178287Sjhb void setDstReg(unsigned SpillReg) { 68132491Stjr DstReg = SpillReg; 69132491Stjr SpilledToReg = true; 70269085Spfg } 71132491Stjr bool isRestored() const { return Restored; } 72132491Stjr void setRestored(bool R) { Restored = R; } 73234528Sdas bool isSpilledToReg() const { return SpilledToReg; } 74103678Stjr}; 75132491Stjr 76101776Stjr/// The MachineFrameInfo class represents an abstract stack frame until 77132491Stjr/// prolog/epilog code is inserted. This class is key to allowing stack frame 78132491Stjr/// representation optimizations, such as frame pointer elimination. It also 79132491Stjr/// allows more mundane (but still important) optimizations, such as reordering 80101776Stjr/// of abstract objects on the stack frame. 81227753Stheraven/// 82227753Stheraven/// To support this, the class assigns unique integer identifiers to stack 83227753Stheraven/// objects requested clients. These identifiers are negative integers for 84227753Stheraven/// fixed stack objects (such as arguments passed on the stack) or nonnegative 85227753Stheraven/// for objects that may be reordered. Instructions which refer to stack 86227753Stheraven/// objects use a special MO_FrameIndex operand to represent these frame 87/// indexes. 88/// 89/// Because this class keeps track of all references to the stack frame, it 90/// knows when a variable sized object is allocated on the stack. This is the 91/// sole condition which prevents frame pointer elimination, which is an 92/// important optimization on register-poor architectures. Because original 93/// variable sized alloca's in the source program are the only source of 94/// variable sized stack objects, it is safe to decide whether there will be 95/// any variable sized objects before all stack objects are known (for 96/// example, register allocator spill code never needs variable sized 97/// objects). 98/// 99/// When prolog/epilog code emission is performed, the final stack frame is 100/// built and the machine instructions are modified to refer to the actual 101/// stack offsets of the object, eliminating all MO_FrameIndex operands from 102/// the program. 103/// 104/// Abstract Stack Frame Information 105class MachineFrameInfo { 106public: 107 /// Stack Smashing Protection (SSP) rules require that vulnerable stack 108 /// allocations are located close the stack protector. 109 enum SSPLayoutKind { 110 SSPLK_None, ///< Did not trigger a stack protector. No effect on data 111 ///< layout. 112 SSPLK_LargeArray, ///< Array or nested array >= SSP-buffer-size. Closest 113 ///< to the stack protector. 114 SSPLK_SmallArray, ///< Array or nested array < SSP-buffer-size. 2nd closest 115 ///< to the stack protector. 116 SSPLK_AddrOf ///< The address of this allocation is exposed and 117 ///< triggered protection. 3rd closest to the protector. 118 }; 119 120private: 121 // Represent a single object allocated on the stack. 122 struct StackObject { 123 // The offset of this object from the stack pointer on entry to 124 // the function. This field has no meaning for a variable sized element. 125 int64_t SPOffset; 126 127 // The size of this object on the stack. 0 means a variable sized object, 128 // ~0ULL means a dead object. 129 uint64_t Size; 130 131 // The required alignment of this stack slot. 132 unsigned Alignment; 133 134 // If true, the value of the stack object is set before 135 // entering the function and is not modified inside the function. By 136 // default, fixed objects are immutable unless marked otherwise. 137 bool isImmutable; 138 139 // If true the stack object is used as spill slot. It 140 // cannot alias any other memory objects. 141 bool isSpillSlot; 142 143 /// If true, this stack slot is used to spill a value (could be deopt 144 /// and/or GC related) over a statepoint. We know that the address of the 145 /// slot can't alias any LLVM IR value. This is very similar to a Spill 146 /// Slot, but is created by statepoint lowering is SelectionDAG, not the 147 /// register allocator. 148 bool isStatepointSpillSlot = false; 149 150 /// Identifier for stack memory type analagous to address space. If this is 151 /// non-0, the meaning is target defined. Offsets cannot be directly 152 /// compared between objects with different stack IDs. The object may not 153 /// necessarily reside in the same contiguous memory block as other stack 154 /// objects. Objects with differing stack IDs should not be merged or 155 /// replaced substituted for each other. 156 // 157 /// It is assumed a target uses consecutive, increasing stack IDs starting 158 /// from 1. 159 uint8_t StackID; 160 161 /// If this stack object is originated from an Alloca instruction 162 /// this value saves the original IR allocation. Can be NULL. 163 const AllocaInst *Alloca; 164 165 // If true, the object was mapped into the local frame 166 // block and doesn't need additional handling for allocation beyond that. 167 bool PreAllocated = false; 168 169 // If true, an LLVM IR value might point to this object. 170 // Normally, spill slots and fixed-offset objects don't alias IR-accessible 171 // objects, but there are exceptions (on PowerPC, for example, some byval 172 // arguments have ABI-prescribed offsets). 173 bool isAliased; 174 175 /// If true, the object has been zero-extended. 176 bool isZExt = false; 177 178 /// If true, the object has been zero-extended. 179 bool isSExt = false; 180 181 uint8_t SSPLayout; 182 183 StackObject(uint64_t Size, unsigned Alignment, int64_t SPOffset, 184 bool IsImmutable, bool IsSpillSlot, const AllocaInst *Alloca, 185 bool IsAliased, uint8_t StackID = 0) 186 : SPOffset(SPOffset), Size(Size), Alignment(Alignment), 187 isImmutable(IsImmutable), isSpillSlot(IsSpillSlot), 188 StackID(StackID), Alloca(Alloca), isAliased(IsAliased), 189 SSPLayout(SSPLK_None) {} 190 }; 191 192 /// The alignment of the stack. 193 unsigned StackAlignment; 194 195 /// Can the stack be realigned. This can be false if the target does not 196 /// support stack realignment, or if the user asks us not to realign the 197 /// stack. In this situation, overaligned allocas are all treated as dynamic 198 /// allocations and the target must handle them as part of DYNAMIC_STACKALLOC 199 /// lowering. All non-alloca stack objects have their alignment clamped to the 200 /// base ABI stack alignment. 201 /// FIXME: There is room for improvement in this case, in terms of 202 /// grouping overaligned allocas into a "secondary stack frame" and 203 /// then only use a single alloca to allocate this frame and only a 204 /// single virtual register to access it. Currently, without such an 205 /// optimization, each such alloca gets its own dynamic realignment. 206 bool StackRealignable; 207 208 /// Whether the function has the \c alignstack attribute. 209 bool ForcedRealign; 210 211 /// The list of stack objects allocated. 212 std::vector<StackObject> Objects; 213 214 /// This contains the number of fixed objects contained on 215 /// the stack. Because fixed objects are stored at a negative index in the 216 /// Objects list, this is also the index to the 0th object in the list. 217 unsigned NumFixedObjects = 0; 218 219 /// This boolean keeps track of whether any variable 220 /// sized objects have been allocated yet. 221 bool HasVarSizedObjects = false; 222 223 /// This boolean keeps track of whether there is a call 224 /// to builtin \@llvm.frameaddress. 225 bool FrameAddressTaken = false; 226 227 /// This boolean keeps track of whether there is a call 228 /// to builtin \@llvm.returnaddress. 229 bool ReturnAddressTaken = false; 230 231 /// This boolean keeps track of whether there is a call 232 /// to builtin \@llvm.experimental.stackmap. 233 bool HasStackMap = false; 234 235 /// This boolean keeps track of whether there is a call 236 /// to builtin \@llvm.experimental.patchpoint. 237 bool HasPatchPoint = false; 238 239 /// The prolog/epilog code inserter calculates the final stack 240 /// offsets for all of the fixed size objects, updating the Objects list 241 /// above. It then updates StackSize to contain the number of bytes that need 242 /// to be allocated on entry to the function. 243 uint64_t StackSize = 0; 244 245 /// The amount that a frame offset needs to be adjusted to 246 /// have the actual offset from the stack/frame pointer. The exact usage of 247 /// this is target-dependent, but it is typically used to adjust between 248 /// SP-relative and FP-relative offsets. E.G., if objects are accessed via 249 /// SP then OffsetAdjustment is zero; if FP is used, OffsetAdjustment is set 250 /// to the distance between the initial SP and the value in FP. For many 251 /// targets, this value is only used when generating debug info (via 252 /// TargetRegisterInfo::getFrameIndexReference); when generating code, the 253 /// corresponding adjustments are performed directly. 254 int OffsetAdjustment = 0; 255 256 /// The prolog/epilog code inserter may process objects that require greater 257 /// alignment than the default alignment the target provides. 258 /// To handle this, MaxAlignment is set to the maximum alignment 259 /// needed by the objects on the current frame. If this is greater than the 260 /// native alignment maintained by the compiler, dynamic alignment code will 261 /// be needed. 262 /// 263 unsigned MaxAlignment = 0; 264 265 /// Set to true if this function adjusts the stack -- e.g., 266 /// when calling another function. This is only valid during and after 267 /// prolog/epilog code insertion. 268 bool AdjustsStack = false; 269 270 /// Set to true if this function has any function calls. 271 bool HasCalls = false; 272 273 /// The frame index for the stack protector. 274 int StackProtectorIdx = -1; 275 276 /// The frame index for the function context. Used for SjLj exceptions. 277 int FunctionContextIdx = -1; 278 279 /// This contains the size of the largest call frame if the target uses frame 280 /// setup/destroy pseudo instructions (as defined in the TargetFrameInfo 281 /// class). This information is important for frame pointer elimination. 282 /// It is only valid during and after prolog/epilog code insertion. 283 unsigned MaxCallFrameSize = ~0u; 284 285 /// The number of bytes of callee saved registers that the target wants to 286 /// report for the current function in the CodeView S_FRAMEPROC record. 287 unsigned CVBytesOfCalleeSavedRegisters = 0; 288 289 /// The prolog/epilog code inserter fills in this vector with each 290 /// callee saved register saved in either the frame or a different 291 /// register. Beyond its use by the prolog/ epilog code inserter, 292 /// this data is used for debug info and exception handling. 293 std::vector<CalleeSavedInfo> CSInfo; 294 295 /// Has CSInfo been set yet? 296 bool CSIValid = false; 297 298 /// References to frame indices which are mapped 299 /// into the local frame allocation block. <FrameIdx, LocalOffset> 300 SmallVector<std::pair<int, int64_t>, 32> LocalFrameObjects; 301 302 /// Size of the pre-allocated local frame block. 303 int64_t LocalFrameSize = 0; 304 305 /// Required alignment of the local object blob, which is the strictest 306 /// alignment of any object in it. 307 unsigned LocalFrameMaxAlign = 0; 308 309 /// Whether the local object blob needs to be allocated together. If not, 310 /// PEI should ignore the isPreAllocated flags on the stack objects and 311 /// just allocate them normally. 312 bool UseLocalStackAllocationBlock = false; 313 314 /// True if the function dynamically adjusts the stack pointer through some 315 /// opaque mechanism like inline assembly or Win32 EH. 316 bool HasOpaqueSPAdjustment = false; 317 318 /// True if the function contains operations which will lower down to 319 /// instructions which manipulate the stack pointer. 320 bool HasCopyImplyingStackAdjustment = false; 321 322 /// True if the function contains a call to the llvm.vastart intrinsic. 323 bool HasVAStart = false; 324 325 /// True if this is a varargs function that contains a musttail call. 326 bool HasMustTailInVarArgFunc = false; 327 328 /// True if this function contains a tail call. If so immutable objects like 329 /// function arguments are no longer so. A tail call *can* override fixed 330 /// stack objects like arguments so we can't treat them as immutable. 331 bool HasTailCall = false; 332 333 /// Not null, if shrink-wrapping found a better place for the prologue. 334 MachineBasicBlock *Save = nullptr; 335 /// Not null, if shrink-wrapping found a better place for the epilogue. 336 MachineBasicBlock *Restore = nullptr; 337 338public: 339 explicit MachineFrameInfo(unsigned StackAlignment, bool StackRealignable, 340 bool ForcedRealign) 341 : StackAlignment(StackAlignment), StackRealignable(StackRealignable), 342 ForcedRealign(ForcedRealign) {} 343 344 /// Return true if there are any stack objects in this function. 345 bool hasStackObjects() const { return !Objects.empty(); } 346 347 /// This method may be called any time after instruction 348 /// selection is complete to determine if the stack frame for this function 349 /// contains any variable sized objects. 350 bool hasVarSizedObjects() const { return HasVarSizedObjects; } 351 352 /// Return the index for the stack protector object. 353 int getStackProtectorIndex() const { return StackProtectorIdx; } 354 void setStackProtectorIndex(int I) { StackProtectorIdx = I; } 355 bool hasStackProtectorIndex() const { return StackProtectorIdx != -1; } 356 357 /// Return the index for the function context object. 358 /// This object is used for SjLj exceptions. 359 int getFunctionContextIndex() const { return FunctionContextIdx; } 360 void setFunctionContextIndex(int I) { FunctionContextIdx = I; } 361 362 /// This method may be called any time after instruction 363 /// selection is complete to determine if there is a call to 364 /// \@llvm.frameaddress in this function. 365 bool isFrameAddressTaken() const { return FrameAddressTaken; } 366 void setFrameAddressIsTaken(bool T) { FrameAddressTaken = T; } 367 368 /// This method may be called any time after 369 /// instruction selection is complete to determine if there is a call to 370 /// \@llvm.returnaddress in this function. 371 bool isReturnAddressTaken() const { return ReturnAddressTaken; } 372 void setReturnAddressIsTaken(bool s) { ReturnAddressTaken = s; } 373 374 /// This method may be called any time after instruction 375 /// selection is complete to determine if there is a call to builtin 376 /// \@llvm.experimental.stackmap. 377 bool hasStackMap() const { return HasStackMap; } 378 void setHasStackMap(bool s = true) { HasStackMap = s; } 379 380 /// This method may be called any time after instruction 381 /// selection is complete to determine if there is a call to builtin 382 /// \@llvm.experimental.patchpoint. 383 bool hasPatchPoint() const { return HasPatchPoint; } 384 void setHasPatchPoint(bool s = true) { HasPatchPoint = s; } 385 386 /// Return the minimum frame object index. 387 int getObjectIndexBegin() const { return -NumFixedObjects; } 388 389 /// Return one past the maximum frame object index. 390 int getObjectIndexEnd() const { return (int)Objects.size()-NumFixedObjects; } 391 392 /// Return the number of fixed objects. 393 unsigned getNumFixedObjects() const { return NumFixedObjects; } 394 395 /// Return the number of objects. 396 unsigned getNumObjects() const { return Objects.size(); } 397 398 /// Map a frame index into the local object block 399 void mapLocalFrameObject(int ObjectIndex, int64_t Offset) { 400 LocalFrameObjects.push_back(std::pair<int, int64_t>(ObjectIndex, Offset)); 401 Objects[ObjectIndex + NumFixedObjects].PreAllocated = true; 402 } 403 404 /// Get the local offset mapping for a for an object. 405 std::pair<int, int64_t> getLocalFrameObjectMap(int i) const { 406 assert (i >= 0 && (unsigned)i < LocalFrameObjects.size() && 407 "Invalid local object reference!"); 408 return LocalFrameObjects[i]; 409 } 410 411 /// Return the number of objects allocated into the local object block. 412 int64_t getLocalFrameObjectCount() const { return LocalFrameObjects.size(); } 413 414 /// Set the size of the local object blob. 415 void setLocalFrameSize(int64_t sz) { LocalFrameSize = sz; } 416 417 /// Get the size of the local object blob. 418 int64_t getLocalFrameSize() const { return LocalFrameSize; } 419 420 /// Required alignment of the local object blob, 421 /// which is the strictest alignment of any object in it. 422 void setLocalFrameMaxAlign(unsigned Align) { LocalFrameMaxAlign = Align; } 423 424 /// Return the required alignment of the local object blob. 425 unsigned getLocalFrameMaxAlign() const { return LocalFrameMaxAlign; } 426 427 /// Get whether the local allocation blob should be allocated together or 428 /// let PEI allocate the locals in it directly. 429 bool getUseLocalStackAllocationBlock() const { 430 return UseLocalStackAllocationBlock; 431 } 432 433 /// setUseLocalStackAllocationBlock - Set whether the local allocation blob 434 /// should be allocated together or let PEI allocate the locals in it 435 /// directly. 436 void setUseLocalStackAllocationBlock(bool v) { 437 UseLocalStackAllocationBlock = v; 438 } 439 440 /// Return true if the object was pre-allocated into the local block. 441 bool isObjectPreAllocated(int ObjectIdx) const { 442 assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() && 443 "Invalid Object Idx!"); 444 return Objects[ObjectIdx+NumFixedObjects].PreAllocated; 445 } 446 447 /// Return the size of the specified object. 448 int64_t getObjectSize(int ObjectIdx) const { 449 assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() && 450 "Invalid Object Idx!"); 451 return Objects[ObjectIdx+NumFixedObjects].Size; 452 } 453 454 /// Change the size of the specified stack object. 455 void setObjectSize(int ObjectIdx, int64_t Size) { 456 assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() && 457 "Invalid Object Idx!"); 458 Objects[ObjectIdx+NumFixedObjects].Size = Size; 459 } 460 461 /// Return the alignment of the specified stack object. 462 unsigned getObjectAlignment(int ObjectIdx) const { 463 assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() && 464 "Invalid Object Idx!"); 465 return Objects[ObjectIdx+NumFixedObjects].Alignment; 466 } 467 468 /// setObjectAlignment - Change the alignment of the specified stack object. 469 void setObjectAlignment(int ObjectIdx, unsigned Align) { 470 assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() && 471 "Invalid Object Idx!"); 472 Objects[ObjectIdx+NumFixedObjects].Alignment = Align; 473 474 // Only ensure max alignment for the default stack. 475 if (getStackID(ObjectIdx) == 0) 476 ensureMaxAlignment(Align); 477 } 478 479 /// Return the underlying Alloca of the specified 480 /// stack object if it exists. Returns 0 if none exists. 481 const AllocaInst* getObjectAllocation(int ObjectIdx) const { 482 assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() && 483 "Invalid Object Idx!"); 484 return Objects[ObjectIdx+NumFixedObjects].Alloca; 485 } 486 487 /// Return the assigned stack offset of the specified object 488 /// from the incoming stack pointer. 489 int64_t getObjectOffset(int ObjectIdx) const { 490 assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() && 491 "Invalid Object Idx!"); 492 assert(!isDeadObjectIndex(ObjectIdx) && 493 "Getting frame offset for a dead object?"); 494 return Objects[ObjectIdx+NumFixedObjects].SPOffset; 495 } 496 497 bool isObjectZExt(int ObjectIdx) const { 498 assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() && 499 "Invalid Object Idx!"); 500 return Objects[ObjectIdx+NumFixedObjects].isZExt; 501 } 502 503 void setObjectZExt(int ObjectIdx, bool IsZExt) { 504 assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() && 505 "Invalid Object Idx!"); 506 Objects[ObjectIdx+NumFixedObjects].isZExt = IsZExt; 507 } 508 509 bool isObjectSExt(int ObjectIdx) const { 510 assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() && 511 "Invalid Object Idx!"); 512 return Objects[ObjectIdx+NumFixedObjects].isSExt; 513 } 514 515 void setObjectSExt(int ObjectIdx, bool IsSExt) { 516 assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() && 517 "Invalid Object Idx!"); 518 Objects[ObjectIdx+NumFixedObjects].isSExt = IsSExt; 519 } 520 521 /// Set the stack frame offset of the specified object. The 522 /// offset is relative to the stack pointer on entry to the function. 523 void setObjectOffset(int ObjectIdx, int64_t SPOffset) { 524 assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() && 525 "Invalid Object Idx!"); 526 assert(!isDeadObjectIndex(ObjectIdx) && 527 "Setting frame offset for a dead object?"); 528 Objects[ObjectIdx+NumFixedObjects].SPOffset = SPOffset; 529 } 530 531 SSPLayoutKind getObjectSSPLayout(int ObjectIdx) const { 532 assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() && 533 "Invalid Object Idx!"); 534 return (SSPLayoutKind)Objects[ObjectIdx+NumFixedObjects].SSPLayout; 535 } 536 537 void setObjectSSPLayout(int ObjectIdx, SSPLayoutKind Kind) { 538 assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() && 539 "Invalid Object Idx!"); 540 assert(!isDeadObjectIndex(ObjectIdx) && 541 "Setting SSP layout for a dead object?"); 542 Objects[ObjectIdx+NumFixedObjects].SSPLayout = Kind; 543 } 544 545 /// Return the number of bytes that must be allocated to hold 546 /// all of the fixed size frame objects. This is only valid after 547 /// Prolog/Epilog code insertion has finalized the stack frame layout. 548 uint64_t getStackSize() const { return StackSize; } 549 550 /// Set the size of the stack. 551 void setStackSize(uint64_t Size) { StackSize = Size; } 552 553 /// Estimate and return the size of the stack frame. 554 unsigned estimateStackSize(const MachineFunction &MF) const; 555 556 /// Return the correction for frame offsets. 557 int getOffsetAdjustment() const { return OffsetAdjustment; } 558 559 /// Set the correction for frame offsets. 560 void setOffsetAdjustment(int Adj) { OffsetAdjustment = Adj; } 561 562 /// Return the alignment in bytes that this function must be aligned to, 563 /// which is greater than the default stack alignment provided by the target. 564 unsigned getMaxAlignment() const { return MaxAlignment; } 565 566 /// Make sure the function is at least Align bytes aligned. 567 void ensureMaxAlignment(unsigned Align); 568 569 /// Return true if this function adjusts the stack -- e.g., 570 /// when calling another function. This is only valid during and after 571 /// prolog/epilog code insertion. 572 bool adjustsStack() const { return AdjustsStack; } 573 void setAdjustsStack(bool V) { AdjustsStack = V; } 574 575 /// Return true if the current function has any function calls. 576 bool hasCalls() const { return HasCalls; } 577 void setHasCalls(bool V) { HasCalls = V; } 578 579 /// Returns true if the function contains opaque dynamic stack adjustments. 580 bool hasOpaqueSPAdjustment() const { return HasOpaqueSPAdjustment; } 581 void setHasOpaqueSPAdjustment(bool B) { HasOpaqueSPAdjustment = B; } 582 583 /// Returns true if the function contains operations which will lower down to 584 /// instructions which manipulate the stack pointer. 585 bool hasCopyImplyingStackAdjustment() const { 586 return HasCopyImplyingStackAdjustment; 587 } 588 void setHasCopyImplyingStackAdjustment(bool B) { 589 HasCopyImplyingStackAdjustment = B; 590 } 591 592 /// Returns true if the function calls the llvm.va_start intrinsic. 593 bool hasVAStart() const { return HasVAStart; } 594 void setHasVAStart(bool B) { HasVAStart = B; } 595 596 /// Returns true if the function is variadic and contains a musttail call. 597 bool hasMustTailInVarArgFunc() const { return HasMustTailInVarArgFunc; } 598 void setHasMustTailInVarArgFunc(bool B) { HasMustTailInVarArgFunc = B; } 599 600 /// Returns true if the function contains a tail call. 601 bool hasTailCall() const { return HasTailCall; } 602 void setHasTailCall() { HasTailCall = true; } 603 604 /// Computes the maximum size of a callframe and the AdjustsStack property. 605 /// This only works for targets defining 606 /// TargetInstrInfo::getCallFrameSetupOpcode(), getCallFrameDestroyOpcode(), 607 /// and getFrameSize(). 608 /// This is usually computed by the prologue epilogue inserter but some 609 /// targets may call this to compute it earlier. 610 void computeMaxCallFrameSize(const MachineFunction &MF); 611 612 /// Return the maximum size of a call frame that must be 613 /// allocated for an outgoing function call. This is only available if 614 /// CallFrameSetup/Destroy pseudo instructions are used by the target, and 615 /// then only during or after prolog/epilog code insertion. 616 /// 617 unsigned getMaxCallFrameSize() const { 618 // TODO: Enable this assert when targets are fixed. 619 //assert(isMaxCallFrameSizeComputed() && "MaxCallFrameSize not computed yet"); 620 if (!isMaxCallFrameSizeComputed()) 621 return 0; 622 return MaxCallFrameSize; 623 } 624 bool isMaxCallFrameSizeComputed() const { 625 return MaxCallFrameSize != ~0u; 626 } 627 void setMaxCallFrameSize(unsigned S) { MaxCallFrameSize = S; } 628 629 /// Returns how many bytes of callee-saved registers the target pushed in the 630 /// prologue. Only used for debug info. 631 unsigned getCVBytesOfCalleeSavedRegisters() const { 632 return CVBytesOfCalleeSavedRegisters; 633 } 634 void setCVBytesOfCalleeSavedRegisters(unsigned S) { 635 CVBytesOfCalleeSavedRegisters = S; 636 } 637 638 /// Create a new object at a fixed location on the stack. 639 /// All fixed objects should be created before other objects are created for 640 /// efficiency. By default, fixed objects are not pointed to by LLVM IR 641 /// values. This returns an index with a negative value. 642 int CreateFixedObject(uint64_t Size, int64_t SPOffset, bool IsImmutable, 643 bool isAliased = false); 644 645 /// Create a spill slot at a fixed location on the stack. 646 /// Returns an index with a negative value. 647 int CreateFixedSpillStackObject(uint64_t Size, int64_t SPOffset, 648 bool IsImmutable = false); 649 650 /// Returns true if the specified index corresponds to a fixed stack object. 651 bool isFixedObjectIndex(int ObjectIdx) const { 652 return ObjectIdx < 0 && (ObjectIdx >= -(int)NumFixedObjects); 653 } 654 655 /// Returns true if the specified index corresponds 656 /// to an object that might be pointed to by an LLVM IR value. 657 bool isAliasedObjectIndex(int ObjectIdx) const { 658 assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() && 659 "Invalid Object Idx!"); 660 return Objects[ObjectIdx+NumFixedObjects].isAliased; 661 } 662 663 /// Returns true if the specified index corresponds to an immutable object. 664 bool isImmutableObjectIndex(int ObjectIdx) const { 665 // Tail calling functions can clobber their function arguments. 666 if (HasTailCall) 667 return false; 668 assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() && 669 "Invalid Object Idx!"); 670 return Objects[ObjectIdx+NumFixedObjects].isImmutable; 671 } 672 673 /// Marks the immutability of an object. 674 void setIsImmutableObjectIndex(int ObjectIdx, bool IsImmutable) { 675 assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() && 676 "Invalid Object Idx!"); 677 Objects[ObjectIdx+NumFixedObjects].isImmutable = IsImmutable; 678 } 679 680 /// Returns true if the specified index corresponds to a spill slot. 681 bool isSpillSlotObjectIndex(int ObjectIdx) const { 682 assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() && 683 "Invalid Object Idx!"); 684 return Objects[ObjectIdx+NumFixedObjects].isSpillSlot; 685 } 686 687 bool isStatepointSpillSlotObjectIndex(int ObjectIdx) const { 688 assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() && 689 "Invalid Object Idx!"); 690 return Objects[ObjectIdx+NumFixedObjects].isStatepointSpillSlot; 691 } 692 693 /// \see StackID 694 uint8_t getStackID(int ObjectIdx) const { 695 return Objects[ObjectIdx+NumFixedObjects].StackID; 696 } 697 698 /// \see StackID 699 void setStackID(int ObjectIdx, uint8_t ID) { 700 assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() && 701 "Invalid Object Idx!"); 702 Objects[ObjectIdx+NumFixedObjects].StackID = ID; 703 // If ID > 0, MaxAlignment may now be overly conservative. 704 // If ID == 0, MaxAlignment will need to be updated separately. 705 } 706 707 /// Returns true if the specified index corresponds to a dead object. 708 bool isDeadObjectIndex(int ObjectIdx) const { 709 assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() && 710 "Invalid Object Idx!"); 711 return Objects[ObjectIdx+NumFixedObjects].Size == ~0ULL; 712 } 713 714 /// Returns true if the specified index corresponds to a variable sized 715 /// object. 716 bool isVariableSizedObjectIndex(int ObjectIdx) const { 717 assert(unsigned(ObjectIdx + NumFixedObjects) < Objects.size() && 718 "Invalid Object Idx!"); 719 return Objects[ObjectIdx + NumFixedObjects].Size == 0; 720 } 721 722 void markAsStatepointSpillSlotObjectIndex(int ObjectIdx) { 723 assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() && 724 "Invalid Object Idx!"); 725 Objects[ObjectIdx+NumFixedObjects].isStatepointSpillSlot = true; 726 assert(isStatepointSpillSlotObjectIndex(ObjectIdx) && "inconsistent"); 727 } 728 729 /// Create a new statically sized stack object, returning 730 /// a nonnegative identifier to represent it. 731 int CreateStackObject(uint64_t Size, unsigned Alignment, bool isSpillSlot, 732 const AllocaInst *Alloca = nullptr, uint8_t ID = 0); 733 734 /// Create a new statically sized stack object that represents a spill slot, 735 /// returning a nonnegative identifier to represent it. 736 int CreateSpillStackObject(uint64_t Size, unsigned Alignment); 737 738 /// Remove or mark dead a statically sized stack object. 739 void RemoveStackObject(int ObjectIdx) { 740 // Mark it dead. 741 Objects[ObjectIdx+NumFixedObjects].Size = ~0ULL; 742 } 743 744 /// Notify the MachineFrameInfo object that a variable sized object has been 745 /// created. This must be created whenever a variable sized object is 746 /// created, whether or not the index returned is actually used. 747 int CreateVariableSizedObject(unsigned Alignment, const AllocaInst *Alloca); 748 749 /// Returns a reference to call saved info vector for the current function. 750 const std::vector<CalleeSavedInfo> &getCalleeSavedInfo() const { 751 return CSInfo; 752 } 753 /// \copydoc getCalleeSavedInfo() 754 std::vector<CalleeSavedInfo> &getCalleeSavedInfo() { return CSInfo; } 755 756 /// Used by prolog/epilog inserter to set the function's callee saved 757 /// information. 758 void setCalleeSavedInfo(const std::vector<CalleeSavedInfo> &CSI) { 759 CSInfo = CSI; 760 } 761 762 /// Has the callee saved info been calculated yet? 763 bool isCalleeSavedInfoValid() const { return CSIValid; } 764 765 void setCalleeSavedInfoValid(bool v) { CSIValid = v; } 766 767 MachineBasicBlock *getSavePoint() const { return Save; } 768 void setSavePoint(MachineBasicBlock *NewSave) { Save = NewSave; } 769 MachineBasicBlock *getRestorePoint() const { return Restore; } 770 void setRestorePoint(MachineBasicBlock *NewRestore) { Restore = NewRestore; } 771 772 /// Return a set of physical registers that are pristine. 773 /// 774 /// Pristine registers hold a value that is useless to the current function, 775 /// but that must be preserved - they are callee saved registers that are not 776 /// saved. 777 /// 778 /// Before the PrologueEpilogueInserter has placed the CSR spill code, this 779 /// method always returns an empty set. 780 BitVector getPristineRegs(const MachineFunction &MF) const; 781 782 /// Used by the MachineFunction printer to print information about 783 /// stack objects. Implemented in MachineFunction.cpp. 784 void print(const MachineFunction &MF, raw_ostream &OS) const; 785 786 /// dump - Print the function to stderr. 787 void dump(const MachineFunction &MF) const; 788}; 789 790} // End llvm namespace 791 792#endif 793