xref: /freebsd/contrib/llvm-project/llvm/lib/CodeGen/PseudoSourceValue.cpp (revision 6966ac055c3b7a39266fb982493330df7a097997)
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