compiler/dex/pass_driver_me.cc

/*
 * Copyright (C) 2014 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 "base/macros.h"
#include "bb_optimizations.h"
#include "compiler_internals.h"
#include "dataflow_iterator.h"
#include "dataflow_iterator-inl.h"
#include "pass_driver_me.h"

namespace art {

namespace {  // anonymous namespace

void DoWalkBasicBlocks(PassMEDataHolder* data, const PassME* pass, DataflowIterator* iterator) {
  // Paranoid: Check the iterator before walking the BasicBlocks.
  DCHECK(iterator != nullptr);
  bool change = false;
  for (BasicBlock *bb = iterator->Next(change); bb != 0; bb = iterator->Next(change)) {
    data->bb = bb;
    change = pass->Worker(data);
  }
}

template <typename Iterator>
inline void DoWalkBasicBlocks(PassMEDataHolder* data, const PassME* pass) {
  DCHECK(data != nullptr);
  CompilationUnit* c_unit = data->c_unit;
  DCHECK(c_unit != nullptr);
  Iterator iterator(c_unit->mir_graph.get());
  DoWalkBasicBlocks(data, pass, &iterator);
}
}  // anonymous namespace

/*
 * Create the pass list. These passes are immutable and are shared across the threads.
 *
 * Advantage is that there will be no race conditions here.
 * Disadvantage is the passes can't change their internal states depending on CompilationUnit:
 *   - This is not yet an issue: no current pass would require it.
 */
// The initial list of passes to be used by the PassDriveME.
template<>
const Pass* const PassDriver<PassDriverME>::g_passes[] = {
  GetPassInstance<CacheFieldLoweringInfo>(),
  GetPassInstance<CacheMethodLoweringInfo>(),
  GetPassInstance<CallInlining>(),
  GetPassInstance<CodeLayout>(),
  GetPassInstance<SSATransformation>(),
  GetPassInstance<ConstantPropagation>(),
  GetPassInstance<InitRegLocations>(),
  GetPassInstance<MethodUseCount>(),
  GetPassInstance<NullCheckEliminationAndTypeInference>(),
  GetPassInstance<ClassInitCheckElimination>(),
  GetPassInstance<BBCombine>(),
  GetPassInstance<BBOptimizations>(),
};

// The number of the passes in the initial list of Passes (g_passes).
template<>
uint16_t const PassDriver<PassDriverME>::g_passes_size = arraysize(PassDriver<PassDriverME>::g_passes);

// The default pass list is used by the PassDriverME instance of PassDriver to initialize pass_list_.
template<>
std::vector<const Pass*> PassDriver<PassDriverME>::g_default_pass_list(PassDriver<PassDriverME>::g_passes, PassDriver<PassDriverME>::g_passes + PassDriver<PassDriverME>::g_passes_size);

// By default, do not have a dump pass list.
template<>
std::string PassDriver<PassDriverME>::dump_pass_list_ = std::string();

// By default, do not have a print pass list.
template<>
std::string PassDriver<PassDriverME>::print_pass_list_ = std::string();

// By default, we do not print the pass' information.
template<>
bool PassDriver<PassDriverME>::default_print_passes_ = false;


PassDriverME::PassDriverME(CompilationUnit* cu)
    : PassDriver(), pass_me_data_holder_(), dump_cfg_folder_("/sdcard/") {
  pass_me_data_holder_.bb = nullptr;
  pass_me_data_holder_.c_unit = cu;
}

PassDriverME::~PassDriverME() {
}

void PassDriverME::DispatchPass(const Pass* pass) {
  VLOG(compiler) << "Dispatching " << pass->GetName();
  const PassME* me_pass = down_cast<const PassME*>(pass);

  DataFlowAnalysisMode mode = me_pass->GetTraversal();

  switch (mode) {
    case kPreOrderDFSTraversal:
      DoWalkBasicBlocks<PreOrderDfsIterator>(&pass_me_data_holder_, me_pass);
      break;
    case kRepeatingPreOrderDFSTraversal:
      DoWalkBasicBlocks<RepeatingPreOrderDfsIterator>(&pass_me_data_holder_, me_pass);
      break;
    case kRepeatingPostOrderDFSTraversal:
      DoWalkBasicBlocks<RepeatingPostOrderDfsIterator>(&pass_me_data_holder_, me_pass);
      break;
    case kReversePostOrderDFSTraversal:
      DoWalkBasicBlocks<ReversePostOrderDfsIterator>(&pass_me_data_holder_, me_pass);
      break;
    case kRepeatingReversePostOrderDFSTraversal:
      DoWalkBasicBlocks<RepeatingReversePostOrderDfsIterator>(&pass_me_data_holder_, me_pass);
      break;
    case kPostOrderDOMTraversal:
      DoWalkBasicBlocks<PostOrderDOMIterator>(&pass_me_data_holder_, me_pass);
      break;
    case kAllNodes:
      DoWalkBasicBlocks<AllNodesIterator>(&pass_me_data_holder_, me_pass);
      break;
    case kNoNodes:
      break;
    default:
      LOG(FATAL) << "Iterator mode not handled in dispatcher: " << mode;
      break;
  }
}

bool PassDriverME::RunPass(const Pass* pass, bool time_split) {
  // Paranoid: c_unit and pass cannot be nullptr, and the pass should have a name
  DCHECK(pass != nullptr);
  DCHECK(pass->GetName() != nullptr && pass->GetName()[0] != 0);
  CompilationUnit* c_unit = pass_me_data_holder_.c_unit;
  DCHECK(c_unit != nullptr);

  // Do we perform a time split
  if (time_split) {
    c_unit->NewTimingSplit(pass->GetName());
  }

  // Check the pass gate first.
  bool should_apply_pass = pass->Gate(&pass_me_data_holder_);

  if (should_apply_pass) {
    bool old_print_pass = c_unit->print_pass;

    c_unit->print_pass = default_print_passes_;

    const char* print_pass_list = print_pass_list_.c_str();

    if (print_pass_list != nullptr && strstr(print_pass_list, pass->GetName()) != nullptr) {
      c_unit->print_pass = true;
    }

    // Applying the pass: first start, doWork, and end calls.
    ApplyPass(&pass_me_data_holder_, pass);

    // Do we want to log it?
    bool should_dump = ((c_unit->enable_debug & (1 << kDebugDumpCFG)) != 0);

    const char* dump_pass_list = dump_pass_list_.c_str();

    if (dump_pass_list != nullptr) {
      bool found = strstr(dump_pass_list, pass->GetName());
      should_dump = (should_dump || found);
    }

    if (should_dump) {
      // Do we want to log it?
      if ((c_unit->enable_debug&  (1 << kDebugDumpCFG)) != 0) {
        // Do we have a pass folder?
        const PassME* me_pass = (down_cast<const PassME*>(pass));
        const char* passFolder = me_pass->GetDumpCFGFolder();
        DCHECK(passFolder != nullptr);

        if (passFolder[0] != 0) {
          // Create directory prefix.
          std::string prefix = GetDumpCFGFolder();
          prefix += passFolder;
          prefix += "/";

          c_unit->mir_graph->DumpCFG(prefix.c_str(), false);
        }
      }
    }

    c_unit->print_pass = old_print_pass;
  }

  // If the pass gate passed, we can declare success.
  return should_apply_pass;
}

const char* PassDriverME::GetDumpCFGFolder() const {
  return dump_cfg_folder_;
}


}  // namespace art