xref: /system/extras/simpleperf/report_utils.cpp

/*
 * Copyright (C) 2020 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 "report_utils.h"

#include <android-base/strings.h>

#include "JITDebugReader.h"
#include "utils.h"

namespace simpleperf {

static bool IsArtEntry(const CallChainReportEntry& entry, bool* is_jni_trampoline) {
  if (entry.execution_type == CallChainExecutionType::NATIVE_METHOD) {
    // art_jni_trampoline/art_quick_generic_jni_trampoline are trampolines used to call jni
    // methods in art runtime. We want to hide them when hiding art frames.
    *is_jni_trampoline = android::base::EndsWith(entry.symbol->Name(), "jni_trampoline");
    return *is_jni_trampoline || android::base::EndsWith(entry.dso->Path(), "/libart.so") ||
           android::base::EndsWith(entry.dso->Path(), "/libartd.so");
  }
  return false;
};

bool CallChainReportBuilder::AddProguardMappingFile(std::string_view mapping_file) {
  // The mapping file format is described in
  // https://www.guardsquare.com/en/products/proguard/manual/retrace.
  LineReader reader(mapping_file);
  if (!reader.Ok()) {
    PLOG(ERROR) << "failed to read " << mapping_file;
    return false;
  }
  ProguardMappingClass* cur_class = nullptr;
  std::string* line;
  while ((line = reader.ReadLine()) != nullptr) {
    std::string_view s = *line;
    if (s.empty() || s[0] == '#') {
      continue;
    }
    auto arrow_pos = s.find(" -> ");
    if (arrow_pos == s.npos) {
      continue;
    }
    auto arrow_end_pos = arrow_pos + strlen(" -> ");

    if (s[0] != ' ') {
      // Match line "original_classname -> obfuscated_classname:".
      if (auto colon_pos = s.find(':', arrow_end_pos); colon_pos != s.npos) {
        std::string_view original_classname = s.substr(0, arrow_pos);
        std::string obfuscated_classname(s.substr(arrow_end_pos, colon_pos - arrow_end_pos));
        cur_class = &proguard_class_map_[obfuscated_classname];
        cur_class->original_classname = original_classname;
      }
    } else if (cur_class != nullptr) {
      // Match line "... [original_classname.]original_methodname(...)... ->
      // obfuscated_methodname".
      if (auto left_brace_pos = s.rfind('(', arrow_pos); left_brace_pos != s.npos) {
        if (auto space_pos = s.rfind(' ', left_brace_pos); space_pos != s.npos) {
          auto original_methodname = s.substr(space_pos + 1, left_brace_pos - space_pos - 1);
          if (android::base::StartsWith(original_methodname, cur_class->original_classname)) {
            original_methodname.remove_prefix(cur_class->original_classname.size() + 1);
          }
          std::string obfuscated_methodname(s.substr(arrow_end_pos));
          cur_class->method_map[obfuscated_methodname] = original_methodname;
        }
      }
    }
  }
  return true;
}

std::vector<CallChainReportEntry> CallChainReportBuilder::Build(const ThreadEntry* thread,
                                                                const std::vector<uint64_t>& ips,
                                                                size_t kernel_ip_count) {
  std::vector<CallChainReportEntry> result;
  result.reserve(ips.size());
  for (size_t i = 0; i < ips.size(); i++) {
    const MapEntry* map = thread_tree_.FindMap(thread, ips[i], i < kernel_ip_count);
    Dso* dso = map->dso;
    uint64_t vaddr_in_file;
    const Symbol* symbol = thread_tree_.FindSymbol(map, ips[i], &vaddr_in_file, &dso);
    CallChainExecutionType execution_type = CallChainExecutionType::NATIVE_METHOD;
    if (dso->IsForJavaMethod()) {
      if (dso->type() == DSO_DEX_FILE) {
        execution_type = CallChainExecutionType::INTERPRETED_JVM_METHOD;
      } else {
        execution_type = CallChainExecutionType::JIT_JVM_METHOD;
      }
    }
    result.resize(result.size() + 1);
    auto& entry = result.back();
    entry.ip = ips[i];
    entry.symbol = symbol;
    entry.dso = dso;
    entry.vaddr_in_file = vaddr_in_file;
    entry.map = map;
    entry.execution_type = execution_type;
  }
  MarkArtFrame(result);
  if (remove_art_frame_) {
    auto it = std::remove_if(result.begin(), result.end(), [](const CallChainReportEntry& entry) {
      return entry.execution_type == CallChainExecutionType::ART_METHOD;
    });
    result.erase(it, result.end());
  }
  if (convert_jit_frame_) {
    ConvertJITFrame(result);
  }
  if (!proguard_class_map_.empty()) {
    DeObfuscateJavaMethods(result);
  }
  return result;
}

void CallChainReportBuilder::MarkArtFrame(std::vector<CallChainReportEntry>& callchain) {
  // Mark art methods before or after a JVM method.
  bool near_java_method = false;
  bool is_jni_trampoline = false;
  std::vector<size_t> jni_trampoline_positions;
  for (size_t i = 0; i < callchain.size(); ++i) {
    auto& entry = callchain[i];
    if (entry.execution_type == CallChainExecutionType::INTERPRETED_JVM_METHOD ||
        entry.execution_type == CallChainExecutionType::JIT_JVM_METHOD) {
      near_java_method = true;

      // Mark art frames before this entry.
      for (int j = static_cast<int>(i) - 1; j >= 0; j--) {
        if (!IsArtEntry(callchain[j], &is_jni_trampoline)) {
          break;
        }
        callchain[j].execution_type = CallChainExecutionType::ART_METHOD;
        if (is_jni_trampoline) {
          jni_trampoline_positions.push_back(j);
        }
      }
    } else if (near_java_method && IsArtEntry(entry, &is_jni_trampoline)) {
      entry.execution_type = CallChainExecutionType::ART_METHOD;
      if (is_jni_trampoline) {
        jni_trampoline_positions.push_back(i);
      }
    } else {
      near_java_method = false;
    }
  }
  // Functions called by art_jni_trampoline are jni methods. And we don't want to hide them.
  for (auto i : jni_trampoline_positions) {
    if (i > 0 && callchain[i - 1].execution_type == CallChainExecutionType::ART_METHOD) {
      callchain[i - 1].execution_type = CallChainExecutionType::NATIVE_METHOD;
    }
  }
}

void CallChainReportBuilder::ConvertJITFrame(std::vector<CallChainReportEntry>& callchain) {
  CollectJavaMethods();
  for (size_t i = 0; i < callchain.size();) {
    auto& entry = callchain[i];
    if (entry.execution_type == CallChainExecutionType::JIT_JVM_METHOD) {
      // This is a JIT java method, merge it with the interpreted java method having the same
      // name if possible. Otherwise, merge it with other JIT java methods having the same name
      // by assigning a common dso_name.
      if (auto it = java_method_map_.find(std::string(entry.symbol->FunctionName()));
          it != java_method_map_.end()) {
        entry.dso = it->second.dso;
        entry.symbol = it->second.symbol;
        // Not enough info to map an offset in a JIT method to an offset in a dex file. So just
        // use the symbol_addr.
        entry.vaddr_in_file = entry.symbol->addr;

        // ART may call from an interpreted Java method into its corresponding JIT method. To
        // avoid showing the method calling itself, remove the JIT frame.
        if (i + 1 < callchain.size() && callchain[i + 1].dso == entry.dso &&
            callchain[i + 1].symbol == entry.symbol) {
          callchain.erase(callchain.begin() + i);
          continue;
        }

      } else if (!JITDebugReader::IsPathInJITSymFile(entry.dso->Path())) {
        // Old JITSymFiles use names like "TemporaryFile-XXXXXX". So give them a better name.
        entry.dso_name = "[JIT cache]";
      }
    }
    i++;
  }
}

void CallChainReportBuilder::CollectJavaMethods() {
  if (!java_method_initialized_) {
    java_method_initialized_ = true;
    for (Dso* dso : thread_tree_.GetAllDsos()) {
      if (dso->type() == DSO_DEX_FILE) {
        dso->LoadSymbols();
        for (auto& symbol : dso->GetSymbols()) {
          java_method_map_.emplace(symbol.Name(), JavaMethod(dso, &symbol));
        }
      }
    }
  }
}

static bool IsJavaEntry(const CallChainReportEntry& entry) {
  static const char* COMPILED_JAVA_FILE_SUFFIXES[] = {".odex", ".oat", ".dex"};
  if (entry.execution_type == CallChainExecutionType::JIT_JVM_METHOD ||
      entry.execution_type == CallChainExecutionType::INTERPRETED_JVM_METHOD) {
    return true;
  }
  if (entry.execution_type == CallChainExecutionType::NATIVE_METHOD) {
    const std::string& path = entry.dso->Path();
    for (const char* suffix : COMPILED_JAVA_FILE_SUFFIXES) {
      if (android::base::EndsWith(path, suffix)) {
        return true;
      }
    }
  }
  return false;
}

void CallChainReportBuilder::DeObfuscateJavaMethods(std::vector<CallChainReportEntry>& callchain) {
  for (auto& entry : callchain) {
    if (!IsJavaEntry(entry)) {
      continue;
    }
    std::string_view name = entry.symbol->FunctionName();
    if (auto split_pos = name.rfind('.'); split_pos != name.npos) {
      std::string obfuscated_classname(name.substr(0, split_pos));
      if (auto it = proguard_class_map_.find(obfuscated_classname);
          it != proguard_class_map_.end()) {
        const ProguardMappingClass& proguard_class = it->second;
        std::string obfuscated_methodname(name.substr(split_pos + 1));
        if (auto method_it = proguard_class.method_map.find(obfuscated_methodname);
            method_it != proguard_class.method_map.end()) {
          std::string new_symbol_name = proguard_class.original_classname + "." + method_it->second;
          entry.symbol->SetDemangledName(new_symbol_name);
        }
      }
    }
  }
}

}  // namespace simpleperf