/* * Copyright (C) 2016 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "pc_relative_fixups_mips.h" #include "code_generator_mips.h" #include "intrinsics_mips.h" namespace art { namespace mips { /** * Finds instructions that need the constant area base as an input. */ class PCRelativeHandlerVisitor : public HGraphVisitor { public: PCRelativeHandlerVisitor(HGraph* graph, CodeGenerator* codegen) : HGraphVisitor(graph), codegen_(down_cast(codegen)), base_(nullptr) {} void MoveBaseIfNeeded() { if (base_ != nullptr) { // Bring the base closer to the first use (previously, it was in the // entry block) and relieve some pressure on the register allocator // while avoiding recalculation of the base in a loop. base_->MoveBeforeFirstUserAndOutOfLoops(); // Computing the base for PC-relative literals will clobber RA with // the NAL instruction on R2. Take a note of this before generating // the method entry. codegen_->ClobberRA(); } } private: void InitializePCRelativeBasePointer() { // Ensure we only initialize the pointer once. if (base_ != nullptr) { return; } // Insert the base at the start of the entry block, move it to a better // position later in MoveBaseIfNeeded(). base_ = new (GetGraph()->GetAllocator()) HMipsComputeBaseMethodAddress(); HBasicBlock* entry_block = GetGraph()->GetEntryBlock(); entry_block->InsertInstructionBefore(base_, entry_block->GetFirstInstruction()); DCHECK(base_ != nullptr); } void VisitInvokeStaticOrDirect(HInvokeStaticOrDirect* invoke) override { // If this is an invoke with PC-relative load kind, // we need to add the base as the special input. if (invoke->HasPcRelativeMethodLoadKind() && !IsCallFreeIntrinsic(invoke, codegen_)) { InitializePCRelativeBasePointer(); // Add the special argument base to the method. DCHECK(!invoke->HasCurrentMethodInput()); invoke->AddSpecialInput(base_); } } void VisitLoadClass(HLoadClass* load_class) override { HLoadClass::LoadKind load_kind = load_class->GetLoadKind(); switch (load_kind) { case HLoadClass::LoadKind::kBootImageLinkTimePcRelative: case HLoadClass::LoadKind::kBootImageRelRo: case HLoadClass::LoadKind::kBssEntry: case HLoadClass::LoadKind::kJitBootImageAddress: // Add a base register for PC-relative literals on R2. InitializePCRelativeBasePointer(); load_class->AddSpecialInput(base_); break; default: break; } } void VisitLoadString(HLoadString* load_string) override { HLoadString::LoadKind load_kind = load_string->GetLoadKind(); switch (load_kind) { case HLoadString::LoadKind::kBootImageLinkTimePcRelative: case HLoadString::LoadKind::kBootImageRelRo: case HLoadString::LoadKind::kBssEntry: case HLoadString::LoadKind::kJitBootImageAddress: // Add a base register for PC-relative literals on R2. InitializePCRelativeBasePointer(); load_string->AddSpecialInput(base_); break; default: break; } } void VisitPackedSwitch(HPackedSwitch* switch_insn) override { if (switch_insn->GetNumEntries() <= InstructionCodeGeneratorMIPS::kPackedSwitchJumpTableThreshold) { return; } // We need to replace the HPackedSwitch with a HMipsPackedSwitch in order to // address the constant area. InitializePCRelativeBasePointer(); HGraph* graph = GetGraph(); HBasicBlock* block = switch_insn->GetBlock(); HMipsPackedSwitch* mips_switch = new (graph->GetAllocator()) HMipsPackedSwitch( switch_insn->GetStartValue(), switch_insn->GetNumEntries(), switch_insn->InputAt(0), base_, switch_insn->GetDexPc()); block->ReplaceAndRemoveInstructionWith(switch_insn, mips_switch); } CodeGeneratorMIPS* codegen_; // The generated HMipsComputeBaseMethodAddress in the entry block needed as an // input to the HMipsLoadFromConstantTable instructions. HMipsComputeBaseMethodAddress* base_; }; bool PcRelativeFixups::Run() { CodeGeneratorMIPS* mips_codegen = down_cast(codegen_); if (mips_codegen->GetInstructionSetFeatures().IsR6()) { // Do nothing for R6 because it has PC-relative addressing. return false; } if (graph_->HasIrreducibleLoops()) { // Do not run this optimization, as irreducible loops do not work with an instruction // that can be live-in at the irreducible loop header. return false; } PCRelativeHandlerVisitor visitor(graph_, codegen_); visitor.VisitInsertionOrder(); visitor.MoveBaseIfNeeded(); return true; } } // namespace mips } // namespace art