cb-extract.h

/*
 * cb-extract.h
 *
 *  Created on: Nov 29, 2016
 *      Author: Fan Gang <fangang@clearblue.com>
 *
 *
 *  The main part of this file is copied from file DebugInfoAnalysis.cpp, please
 * keep sync when it is changing.
 */

#ifndef TOOLS_PP_EXTRACT_PP_EXTRACT_H_
#define TOOLS_PP_EXTRACT_PP_EXTRACT_H_

#include "Utils/ADT/kvec.h"
#include "Utils/ADT/kvec_ext.h"
#include "Utils/StringUtils.h"
#include <llvm/IR/DebugInfo.h>
#include <llvm/Support/Allocator.h>
#include <unordered_map>

using namespace llvm;

// Use a memory allocator to manage the char array allocated on heap
// The memory will be automatically released
BumpPtrAllocator string_allocator;
// Reconstruct the path of the source code files in a simpler form
template <int initN>
StringRef synthesize_file_path(StringRef File, StringRef Dir,
                               kvec_str<initN> &path_result) {
  path_result.clear();

  StringRef path_have_root_name;

  if (!sys::path::is_absolute(File)) {
    // When the file name is not an absolute path,
    // we should concatenate the dir and file name to obtain the full path
    path_result.fill(Dir.data(), Dir.size());
    path_have_root_name = Dir;
  } else {
    path_have_root_name = File;
  }

  // It could be that current system is Linux but the input bitcode is generated
  // on windows or vice versa.
  char input_bc_path_sep = '/';
  if (path_have_root_name.size() >= 3 && (path_have_root_name[1] == ':') &&
      (path_have_root_name[2] == '\\')) {
    input_bc_path_sep = '\\';
  }

  bool first_comp = true;
  for (sys::path::const_iterator it = sys::path::begin(File),
                                 ie = sys::path::end(File);
       it != ie; ++it, first_comp = false) {
    StringRef component = *it;

    if (component == "..") {
      int pos = path_result.rfind(input_bc_path_sep);
      if (pos > 0) {
        path_result.erase_substr(pos);
      } else {
        // If current path is already at root, .. has no effect
      }
    } else if (component != ".") {
      // Append component to the path, including the root symbol /

      if (first_comp) {
        // The first component is either a root name (e.g. //net) or a root
        // directory (e.g. /) The root name has special meaning on Windows, we
        // should keep it intact

        if (component == sys::path::root_name(File)) {
          // On Unix system, a path starts with "//net" can be erroneously
          // determined as a root name by sys::path::root_name. However, "//net"
          // is actually writing the root symbol "//" twice and it is equal to
          // "/net". Therefore, we handle the wrong root name determination
          // here.

          size_t last_bslash = component.rfind("/");
          if (last_bslash != StringRef::npos) {
            component = component.substr(last_bslash);
          } else {
            // This is perhaps a real root name.
            // It is either the windows driver letter (e.g. C:)
            // or the "server_host" in the remote path "server_host:/home/xx"
            // defined by file URI scheme specification. We just keep the
            // component unchanged.
          }
        }
      }

      // Add a backslash if the component does not start with a separator and
      // the synthesized path is not ended with a separator
      if (!component.startswith(StringRef(&input_bc_path_sep, 1)) &&
          (path_result.empty() || path_result.back() != input_bc_path_sep))
        path_result.push_back(input_bc_path_sep);

      // Add the component
      path_result.append_str(component.data(), component.size());
    }
  }

  // First look up the global cache
  // We do not set trailing zero for file name StringRef
  StringRef file_name(path_result.c_str(), path_result.size());
  file_name = hooked_format_str(string_allocator, "%s", path_result.c_str());
  return file_name;
}

std::unique_ptr<std::unordered_map<const Function *, StringRef>>
getFunctionSrcFiles(Module &M) {

  auto pFuncSrcFileCache =
      std::unique_ptr<std::unordered_map<const Function *, StringRef>>(
          new std::unordered_map<const Function *, StringRef>());

  // Scan the debug information placed at the end of module
  DebugInfoFinder DbgFinder;
  DbgFinder.processModule(M);
  kvec_str<512> tmp_src_path;

  // Cache the function information
  auto it_func_range = DbgFinder.subprograms();
  for (auto it = it_func_range.begin(), ie = it_func_range.end(); it != ie;
       ++it) {
    const DISubprogram &f_loc = *it;

    Function *F = f_loc.getFunction();
    StringRef File = f_loc.getFilename();
    StringRef Dir = f_loc.getDirectory();
    if (File.data() && Dir.data()) {
      (*pFuncSrcFileCache)[F] = synthesize_file_path(File, Dir, tmp_src_path);
    } else {
      (*pFuncSrcFileCache)[F] = "";
    }
  }
  return pFuncSrcFileCache;
}

#endif /* TOOLS_PP_EXTRACT_PP_EXTRACT_H_ */