Home | History | Annotate | Download | only in optimizing 
      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:
     29   PCRelativeHandlerVisitor(HGraph* graph, CodeGenerator* codegen)
     30       : HGraphVisitor(graph),
     31         codegen_(down_cast<CodeGeneratorX86*>(codegen)),
     32         base_(nullptr) {}
     33 
     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:
     44   void VisitAdd(HAdd* add) OVERRIDE {
     45     BinaryFP(add);
     46   }
     47 
     48   void VisitSub(HSub* sub) OVERRIDE {
     49     BinaryFP(sub);
     50   }
     51 
     52   void VisitMul(HMul* mul) OVERRIDE {
     53     BinaryFP(mul);
     54   }
     55 
     56   void VisitDiv(HDiv* div) OVERRIDE {
     57     BinaryFP(div);
     58   }
     59 
     60   void VisitCompare(HCompare* compare) OVERRIDE {
     61     BinaryFP(compare);
     62   }
     63 
     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 
     71   void VisitInvokeStaticOrDirect(HInvokeStaticOrDirect* invoke) OVERRIDE {
     72     HandleInvoke(invoke);
     73   }
     74 
     75   void VisitInvokeVirtual(HInvokeVirtual* invoke) OVERRIDE {
     76     HandleInvoke(invoke);
     77   }
     78 
     79   void VisitInvokeInterface(HInvokeInterface* invoke) OVERRIDE {
     80     HandleInvoke(invoke);
     81   }
     82 
     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 
     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 
    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 
    110   void VisitEqual(HEqual* cond) OVERRIDE {
    111     BinaryFP(cond);
    112   }
    113 
    114   void VisitNotEqual(HNotEqual* cond) OVERRIDE {
    115     BinaryFP(cond);
    116   }
    117 
    118   void VisitLessThan(HLessThan* cond) OVERRIDE {
    119     BinaryFP(cond);
    120   }
    121 
    122   void VisitLessThanOrEqual(HLessThanOrEqual* cond) OVERRIDE {
    123     BinaryFP(cond);
    124   }
    125 
    126   void VisitGreaterThan(HGreaterThan* cond) OVERRIDE {
    127     BinaryFP(cond);
    128   }
    129 
    130   void VisitGreaterThanOrEqual(HGreaterThanOrEqual* cond) OVERRIDE {
    131     BinaryFP(cond);
    132   }
    133 
    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 
    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 
    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 
    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 
    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 
    262 void PcRelativeFixups::Run() {
    263   PCRelativeHandlerVisitor visitor(graph_, codegen_);
    264   visitor.VisitInsertionOrder();
    265   visitor.MoveBaseIfNeeded();
    266 }
    267 
    268 }  // namespace x86
    269 }  // namespace art
    270