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