1 /*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "pc_relative_fixups_x86.h"
18 #include "code_generator_x86.h"
19 #include "intrinsics_x86.h"
20
21 namespace art {
22 namespace x86 {
23
24 /**
25 * Finds instructions that need the constant area base as an input.
26 */
27 class PCRelativeHandlerVisitor : public HGraphVisitor {
28 public:
PCRelativeHandlerVisitor(HGraph * graph,CodeGenerator * codegen)29 PCRelativeHandlerVisitor(HGraph* graph, CodeGenerator* codegen)
30 : HGraphVisitor(graph),
31 codegen_(down_cast<CodeGeneratorX86*>(codegen)),
32 base_(nullptr) {}
33
MoveBaseIfNeeded()34 void MoveBaseIfNeeded() {
35 if (base_ != nullptr) {
36 // Bring the base closer to the first use (previously, it was in the
37 // entry block) and relieve some pressure on the register allocator
38 // while avoiding recalculation of the base in a loop.
39 base_->MoveBeforeFirstUserAndOutOfLoops();
40 }
41 }
42
43 private:
VisitAdd(HAdd * add)44 void VisitAdd(HAdd* add) OVERRIDE {
45 BinaryFP(add);
46 }
47
VisitSub(HSub * sub)48 void VisitSub(HSub* sub) OVERRIDE {
49 BinaryFP(sub);
50 }
51
VisitMul(HMul * mul)52 void VisitMul(HMul* mul) OVERRIDE {
53 BinaryFP(mul);
54 }
55
VisitDiv(HDiv * div)56 void VisitDiv(HDiv* div) OVERRIDE {
57 BinaryFP(div);
58 }
59
VisitCompare(HCompare * compare)60 void VisitCompare(HCompare* compare) OVERRIDE {
61 BinaryFP(compare);
62 }
63
VisitReturn(HReturn * ret)64 void VisitReturn(HReturn* ret) OVERRIDE {
65 HConstant* value = ret->InputAt(0)->AsConstant();
66 if ((value != nullptr && DataType::IsFloatingPointType(value->GetType()))) {
67 ReplaceInput(ret, value, 0, true);
68 }
69 }
70
VisitInvokeStaticOrDirect(HInvokeStaticOrDirect * invoke)71 void VisitInvokeStaticOrDirect(HInvokeStaticOrDirect* invoke) OVERRIDE {
72 HandleInvoke(invoke);
73 }
74
VisitInvokeVirtual(HInvokeVirtual * invoke)75 void VisitInvokeVirtual(HInvokeVirtual* invoke) OVERRIDE {
76 HandleInvoke(invoke);
77 }
78
VisitInvokeInterface(HInvokeInterface * invoke)79 void VisitInvokeInterface(HInvokeInterface* invoke) OVERRIDE {
80 HandleInvoke(invoke);
81 }
82
VisitLoadClass(HLoadClass * load_class)83 void VisitLoadClass(HLoadClass* load_class) OVERRIDE {
84 HLoadClass::LoadKind load_kind = load_class->GetLoadKind();
85 if (load_kind == HLoadClass::LoadKind::kBootImageLinkTimePcRelative ||
86 load_kind == HLoadClass::LoadKind::kBootImageClassTable ||
87 load_kind == HLoadClass::LoadKind::kBssEntry) {
88 HX86ComputeBaseMethodAddress* method_address = GetPCRelativeBasePointer(load_class);
89 load_class->AddSpecialInput(method_address);
90 }
91 }
92
VisitLoadString(HLoadString * load_string)93 void VisitLoadString(HLoadString* load_string) OVERRIDE {
94 HLoadString::LoadKind load_kind = load_string->GetLoadKind();
95 if (load_kind == HLoadString::LoadKind::kBootImageLinkTimePcRelative ||
96 load_kind == HLoadString::LoadKind::kBootImageInternTable ||
97 load_kind == HLoadString::LoadKind::kBssEntry) {
98 HX86ComputeBaseMethodAddress* method_address = GetPCRelativeBasePointer(load_string);
99 load_string->AddSpecialInput(method_address);
100 }
101 }
102
BinaryFP(HBinaryOperation * bin)103 void BinaryFP(HBinaryOperation* bin) {
104 HConstant* rhs = bin->InputAt(1)->AsConstant();
105 if (rhs != nullptr && DataType::IsFloatingPointType(rhs->GetType())) {
106 ReplaceInput(bin, rhs, 1, false);
107 }
108 }
109
VisitEqual(HEqual * cond)110 void VisitEqual(HEqual* cond) OVERRIDE {
111 BinaryFP(cond);
112 }
113
VisitNotEqual(HNotEqual * cond)114 void VisitNotEqual(HNotEqual* cond) OVERRIDE {
115 BinaryFP(cond);
116 }
117
VisitLessThan(HLessThan * cond)118 void VisitLessThan(HLessThan* cond) OVERRIDE {
119 BinaryFP(cond);
120 }
121
VisitLessThanOrEqual(HLessThanOrEqual * cond)122 void VisitLessThanOrEqual(HLessThanOrEqual* cond) OVERRIDE {
123 BinaryFP(cond);
124 }
125
VisitGreaterThan(HGreaterThan * cond)126 void VisitGreaterThan(HGreaterThan* cond) OVERRIDE {
127 BinaryFP(cond);
128 }
129
VisitGreaterThanOrEqual(HGreaterThanOrEqual * cond)130 void VisitGreaterThanOrEqual(HGreaterThanOrEqual* cond) OVERRIDE {
131 BinaryFP(cond);
132 }
133
VisitNeg(HNeg * neg)134 void VisitNeg(HNeg* neg) OVERRIDE {
135 if (DataType::IsFloatingPointType(neg->GetType())) {
136 // We need to replace the HNeg with a HX86FPNeg in order to address the constant area.
137 HX86ComputeBaseMethodAddress* method_address = GetPCRelativeBasePointer(neg);
138 HGraph* graph = GetGraph();
139 HBasicBlock* block = neg->GetBlock();
140 HX86FPNeg* x86_fp_neg = new (graph->GetAllocator()) HX86FPNeg(
141 neg->GetType(),
142 neg->InputAt(0),
143 method_address,
144 neg->GetDexPc());
145 block->ReplaceAndRemoveInstructionWith(neg, x86_fp_neg);
146 }
147 }
148
VisitPackedSwitch(HPackedSwitch * switch_insn)149 void VisitPackedSwitch(HPackedSwitch* switch_insn) OVERRIDE {
150 if (switch_insn->GetNumEntries() <=
151 InstructionCodeGeneratorX86::kPackedSwitchJumpTableThreshold) {
152 return;
153 }
154 // We need to replace the HPackedSwitch with a HX86PackedSwitch in order to
155 // address the constant area.
156 HX86ComputeBaseMethodAddress* method_address = GetPCRelativeBasePointer(switch_insn);
157 HGraph* graph = GetGraph();
158 HBasicBlock* block = switch_insn->GetBlock();
159 HX86PackedSwitch* x86_switch = new (graph->GetAllocator()) HX86PackedSwitch(
160 switch_insn->GetStartValue(),
161 switch_insn->GetNumEntries(),
162 switch_insn->InputAt(0),
163 method_address,
164 switch_insn->GetDexPc());
165 block->ReplaceAndRemoveInstructionWith(switch_insn, x86_switch);
166 }
167
GetPCRelativeBasePointer(HInstruction * cursor)168 HX86ComputeBaseMethodAddress* GetPCRelativeBasePointer(HInstruction* cursor) {
169 bool has_irreducible_loops = GetGraph()->HasIrreducibleLoops();
170 if (!has_irreducible_loops) {
171 // Ensure we only initialize the pointer once.
172 if (base_ != nullptr) {
173 return base_;
174 }
175 }
176 // Insert the base at the start of the entry block, move it to a better
177 // position later in MoveBaseIfNeeded().
178 HX86ComputeBaseMethodAddress* method_address =
179 new (GetGraph()->GetAllocator()) HX86ComputeBaseMethodAddress();
180 if (has_irreducible_loops) {
181 cursor->GetBlock()->InsertInstructionBefore(method_address, cursor);
182 } else {
183 HBasicBlock* entry_block = GetGraph()->GetEntryBlock();
184 entry_block->InsertInstructionBefore(method_address, entry_block->GetFirstInstruction());
185 base_ = method_address;
186 }
187 return method_address;
188 }
189
ReplaceInput(HInstruction * insn,HConstant * value,int input_index,bool materialize)190 void ReplaceInput(HInstruction* insn, HConstant* value, int input_index, bool materialize) {
191 HX86ComputeBaseMethodAddress* method_address = GetPCRelativeBasePointer(insn);
192 HX86LoadFromConstantTable* load_constant =
193 new (GetGraph()->GetAllocator()) HX86LoadFromConstantTable(method_address, value);
194 if (!materialize) {
195 load_constant->MarkEmittedAtUseSite();
196 }
197 insn->GetBlock()->InsertInstructionBefore(load_constant, insn);
198 insn->ReplaceInput(load_constant, input_index);
199 }
200
HandleInvoke(HInvoke * invoke)201 void HandleInvoke(HInvoke* invoke) {
202 // If this is an invoke-static/-direct with PC-relative dex cache array
203 // addressing, we need the PC-relative address base.
204 HInvokeStaticOrDirect* invoke_static_or_direct = invoke->AsInvokeStaticOrDirect();
205 // We can't add a pointer to the constant area if we already have a current
206 // method pointer. This may arise when sharpening doesn't remove the current
207 // method pointer from the invoke.
208 if (invoke_static_or_direct != nullptr &&
209 invoke_static_or_direct->HasCurrentMethodInput()) {
210 DCHECK(!invoke_static_or_direct->HasPcRelativeMethodLoadKind());
211 return;
212 }
213
214 bool base_added = false;
215 if (invoke_static_or_direct != nullptr &&
216 invoke_static_or_direct->HasPcRelativeMethodLoadKind() &&
217 !IsCallFreeIntrinsic<IntrinsicLocationsBuilderX86>(invoke, codegen_)) {
218 HX86ComputeBaseMethodAddress* method_address = GetPCRelativeBasePointer(invoke);
219 // Add the extra parameter.
220 invoke_static_or_direct->AddSpecialInput(method_address);
221 base_added = true;
222 }
223
224 // Ensure that we can load FP arguments from the constant area.
225 HInputsRef inputs = invoke->GetInputs();
226 for (size_t i = 0; i < inputs.size(); i++) {
227 HConstant* input = inputs[i]->AsConstant();
228 if (input != nullptr && DataType::IsFloatingPointType(input->GetType())) {
229 ReplaceInput(invoke, input, i, true);
230 }
231 }
232
233 // These intrinsics need the constant area.
234 switch (invoke->GetIntrinsic()) {
235 case Intrinsics::kMathAbsDouble:
236 case Intrinsics::kMathAbsFloat:
237 case Intrinsics::kMathMaxDoubleDouble:
238 case Intrinsics::kMathMaxFloatFloat:
239 case Intrinsics::kMathMinDoubleDouble:
240 case Intrinsics::kMathMinFloatFloat:
241 case Intrinsics::kMathRoundFloat:
242 if (!base_added) {
243 DCHECK(invoke_static_or_direct != nullptr);
244 DCHECK(!invoke_static_or_direct->HasCurrentMethodInput());
245 HX86ComputeBaseMethodAddress* method_address = GetPCRelativeBasePointer(invoke);
246 invoke_static_or_direct->AddSpecialInput(method_address);
247 }
248 break;
249 default:
250 break;
251 }
252 }
253
254 CodeGeneratorX86* codegen_;
255
256 // The generated HX86ComputeBaseMethodAddress in the entry block needed as an
257 // input to the HX86LoadFromConstantTable instructions. Only set for
258 // graphs with reducible loops.
259 HX86ComputeBaseMethodAddress* base_;
260 };
261
Run()262 void PcRelativeFixups::Run() {
263 PCRelativeHandlerVisitor visitor(graph_, codegen_);
264 visitor.VisitInsertionOrder();
265 visitor.MoveBaseIfNeeded();
266 }
267
268 } // namespace x86
269 } // namespace art
270