Home | History | Annotate | Download | only in driver 
      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 "compiler_options.h"
     18 
     19 #include <fstream>
     20 
     21 #include "android-base/stringprintf.h"
     22 
     23 #include "base/runtime_debug.h"
     24 #include "base/variant_map.h"
     25 #include "cmdline_parser.h"
     26 #include "compiler_options_map-inl.h"
     27 #include "runtime.h"
     28 #include "simple_compiler_options_map.h"
     29 
     30 namespace art {
     31 
     32 CompilerOptions::CompilerOptions()
     33     : compiler_filter_(CompilerFilter::kDefaultCompilerFilter),
     34       huge_method_threshold_(kDefaultHugeMethodThreshold),
     35       large_method_threshold_(kDefaultLargeMethodThreshold),
     36       small_method_threshold_(kDefaultSmallMethodThreshold),
     37       tiny_method_threshold_(kDefaultTinyMethodThreshold),
     38       num_dex_methods_threshold_(kDefaultNumDexMethodsThreshold),
     39       inline_max_code_units_(kUnsetInlineMaxCodeUnits),
     40       no_inline_from_(nullptr),
     41       boot_image_(false),
     42       core_image_(false),
     43       app_image_(false),
     44       top_k_profile_threshold_(kDefaultTopKProfileThreshold),
     45       debuggable_(false),
     46       generate_debug_info_(kDefaultGenerateDebugInfo),
     47       generate_mini_debug_info_(kDefaultGenerateMiniDebugInfo),
     48       generate_build_id_(false),
     49       implicit_null_checks_(true),
     50       implicit_so_checks_(true),
     51       implicit_suspend_checks_(false),
     52       compile_pic_(false),
     53       dump_timings_(false),
     54       dump_stats_(false),
     55       verbose_methods_(),
     56       abort_on_hard_verifier_failure_(false),
     57       abort_on_soft_verifier_failure_(false),
     58       init_failure_output_(nullptr),
     59       dump_cfg_file_name_(""),
     60       dump_cfg_append_(false),
     61       force_determinism_(false),
     62       deduplicate_code_(true),
     63       count_hotness_in_compiled_code_(false),
     64       register_allocation_strategy_(RegisterAllocator::kRegisterAllocatorDefault),
     65       passes_to_run_(nullptr) {
     66 }
     67 
     68 CompilerOptions::~CompilerOptions() {
     69   // The destructor looks empty but it destroys a PassManagerOptions object. We keep it here
     70   // because we don't want to include the PassManagerOptions definition from the header file.
     71 }
     72 
     73 namespace {
     74 
     75 bool kEmitRuntimeReadBarrierChecks = kIsDebugBuild &&
     76     RegisterRuntimeDebugFlag(&kEmitRuntimeReadBarrierChecks);
     77 
     78 }  // namespace
     79 
     80 bool CompilerOptions::EmitRunTimeChecksInDebugMode() const {
     81   // Run-time checks (e.g. Marking Register checks) are only emitted in slow-debug mode.
     82   return kEmitRuntimeReadBarrierChecks;
     83 }
     84 
     85 bool CompilerOptions::ParseDumpInitFailures(const std::string& option, std::string* error_msg) {
     86   init_failure_output_.reset(new std::ofstream(option));
     87   if (init_failure_output_.get() == nullptr) {
     88     *error_msg = "Failed to construct std::ofstream";
     89     return false;
     90   } else if (init_failure_output_->fail()) {
     91     *error_msg = android::base::StringPrintf(
     92         "Failed to open %s for writing the initialization failures.", option.c_str());
     93     init_failure_output_.reset();
     94     return false;
     95   }
     96   return true;
     97 }
     98 
     99 bool CompilerOptions::ParseRegisterAllocationStrategy(const std::string& option,
    100                                                       std::string* error_msg) {
    101   if (option == "linear-scan") {
    102     register_allocation_strategy_ = RegisterAllocator::Strategy::kRegisterAllocatorLinearScan;
    103   } else if (option == "graph-color") {
    104     register_allocation_strategy_ = RegisterAllocator::Strategy::kRegisterAllocatorGraphColor;
    105   } else {
    106     *error_msg = "Unrecognized register allocation strategy. Try linear-scan, or graph-color.";
    107     return false;
    108   }
    109   return true;
    110 }
    111 
    112 #pragma GCC diagnostic push
    113 #pragma GCC diagnostic ignored "-Wframe-larger-than="
    114 
    115 bool CompilerOptions::ParseCompilerOptions(const std::vector<std::string>& options,
    116                                            bool ignore_unrecognized,
    117                                            std::string* error_msg) {
    118   auto parser = CreateSimpleParser(ignore_unrecognized);
    119   CmdlineResult parse_result = parser.Parse(options);
    120   if (!parse_result.IsSuccess()) {
    121     *error_msg = parse_result.GetMessage();
    122     return false;
    123   }
    124 
    125   SimpleParseArgumentMap args = parser.ReleaseArgumentsMap();
    126   return ReadCompilerOptions(args, this, error_msg);
    127 }
    128 
    129 #pragma GCC diagnostic pop
    130 
    131 }  // namespace art
    132