1 //===-- llvm/CodeGen/PseudoSourceValue.cpp ----------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file implements the PseudoSourceValue class. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "llvm/CodeGen/PseudoSourceValue.h" 14 #include "llvm/ADT/STLExtras.h" 15 #include "llvm/CodeGen/MachineFrameInfo.h" 16 #include "llvm/CodeGen/TargetInstrInfo.h" 17 #include "llvm/IR/DerivedTypes.h" 18 #include "llvm/IR/LLVMContext.h" 19 #include "llvm/Support/ErrorHandling.h" 20 #include "llvm/Support/raw_ostream.h" 21 using namespace llvm; 22 23 static const char *const PSVNames[] = { 24 "Stack", "GOT", "JumpTable", "ConstantPool", "FixedStack", 25 "GlobalValueCallEntry", "ExternalSymbolCallEntry"}; 26 27 PseudoSourceValue::PseudoSourceValue(unsigned Kind, const TargetInstrInfo &TII) 28 : Kind(Kind) { 29 AddressSpace = TII.getAddressSpaceForPseudoSourceKind(Kind); 30 } 31 32 33 PseudoSourceValue::~PseudoSourceValue() {} 34 35 void PseudoSourceValue::printCustom(raw_ostream &O) const { 36 if (Kind < TargetCustom) 37 O << PSVNames[Kind]; 38 else 39 O << "TargetCustom" << Kind; 40 } 41 42 bool PseudoSourceValue::isConstant(const MachineFrameInfo *) const { 43 if (isStack()) 44 return false; 45 if (isGOT() || isConstantPool() || isJumpTable()) 46 return true; 47 llvm_unreachable("Unknown PseudoSourceValue!"); 48 } 49 50 bool PseudoSourceValue::isAliased(const MachineFrameInfo *) const { 51 if (isStack() || isGOT() || isConstantPool() || isJumpTable()) 52 return false; 53 llvm_unreachable("Unknown PseudoSourceValue!"); 54 } 55 56 bool PseudoSourceValue::mayAlias(const MachineFrameInfo *) const { 57 return !(isGOT() || isConstantPool() || isJumpTable()); 58 } 59 60 bool FixedStackPseudoSourceValue::isConstant( 61 const MachineFrameInfo *MFI) const { 62 return MFI && MFI->isImmutableObjectIndex(FI); 63 } 64 65 bool FixedStackPseudoSourceValue::isAliased(const MachineFrameInfo *MFI) const { 66 if (!MFI) 67 return true; 68 return MFI->isAliasedObjectIndex(FI); 69 } 70 71 bool FixedStackPseudoSourceValue::mayAlias(const MachineFrameInfo *MFI) const { 72 if (!MFI) 73 return true; 74 // Spill slots will not alias any LLVM IR value. 75 return !MFI->isSpillSlotObjectIndex(FI); 76 } 77 78 void FixedStackPseudoSourceValue::printCustom(raw_ostream &OS) const { 79 OS << "FixedStack" << FI; 80 } 81 82 CallEntryPseudoSourceValue::CallEntryPseudoSourceValue( 83 unsigned Kind, const TargetInstrInfo &TII) 84 : PseudoSourceValue(Kind, TII) {} 85 86 bool CallEntryPseudoSourceValue::isConstant(const MachineFrameInfo *) const { 87 return false; 88 } 89 90 bool CallEntryPseudoSourceValue::isAliased(const MachineFrameInfo *) const { 91 return false; 92 } 93 94 bool CallEntryPseudoSourceValue::mayAlias(const MachineFrameInfo *) const { 95 return false; 96 } 97 98 GlobalValuePseudoSourceValue::GlobalValuePseudoSourceValue( 99 const GlobalValue *GV, 100 const TargetInstrInfo &TII) 101 : CallEntryPseudoSourceValue(GlobalValueCallEntry, TII), GV(GV) {} 102 ExternalSymbolPseudoSourceValue::ExternalSymbolPseudoSourceValue( 103 const char *ES, const TargetInstrInfo &TII) 104 : CallEntryPseudoSourceValue(ExternalSymbolCallEntry, TII), ES(ES) {} 105 106 PseudoSourceValueManager::PseudoSourceValueManager( 107 const TargetInstrInfo &TIInfo) 108 : TII(TIInfo), 109 StackPSV(PseudoSourceValue::Stack, TII), 110 GOTPSV(PseudoSourceValue::GOT, TII), 111 JumpTablePSV(PseudoSourceValue::JumpTable, TII), 112 ConstantPoolPSV(PseudoSourceValue::ConstantPool, TII) {} 113 114 const PseudoSourceValue *PseudoSourceValueManager::getStack() { 115 return &StackPSV; 116 } 117 118 const PseudoSourceValue *PseudoSourceValueManager::getGOT() { return &GOTPSV; } 119 120 const PseudoSourceValue *PseudoSourceValueManager::getConstantPool() { 121 return &ConstantPoolPSV; 122 } 123 124 const PseudoSourceValue *PseudoSourceValueManager::getJumpTable() { 125 return &JumpTablePSV; 126 } 127 128 const PseudoSourceValue * 129 PseudoSourceValueManager::getFixedStack(int FI) { 130 std::unique_ptr<FixedStackPseudoSourceValue> &V = FSValues[FI]; 131 if (!V) 132 V = llvm::make_unique<FixedStackPseudoSourceValue>(FI, TII); 133 return V.get(); 134 } 135 136 const PseudoSourceValue * 137 PseudoSourceValueManager::getGlobalValueCallEntry(const GlobalValue *GV) { 138 std::unique_ptr<const GlobalValuePseudoSourceValue> &E = 139 GlobalCallEntries[GV]; 140 if (!E) 141 E = llvm::make_unique<GlobalValuePseudoSourceValue>(GV, TII); 142 return E.get(); 143 } 144 145 const PseudoSourceValue * 146 PseudoSourceValueManager::getExternalSymbolCallEntry(const char *ES) { 147 std::unique_ptr<const ExternalSymbolPseudoSourceValue> &E = 148 ExternalCallEntries[ES]; 149 if (!E) 150 E = llvm::make_unique<ExternalSymbolPseudoSourceValue>(ES, TII); 151 return E.get(); 152 } 153