src/mc/inspect/ObjectInformation.hpp

   1 /* Copyright (c) 2007-2022. The SimGrid Team. All rights reserved.          */
   2
   3 /* This program is free software; you can redistribute it and/or modify it
   4  * under the terms of the license (GNU LGPL) which comes with this package. */
   5
   6 #ifndef SIMGRID_MC_OBJECT_INFORMATION_HPP
   7 #define SIMGRID_MC_OBJECT_INFORMATION_HPP
   8
   9 #include <memory>
  10 #include <string>
  11 #include <unordered_map>
  12 #include <vector>
  13
  14 #include "src/mc/inspect/Frame.hpp"
  15 #include "src/mc/inspect/Type.hpp"
  16 #include "src/mc/mc_forward.hpp"
  17 #include "src/xbt/memory_map.hpp"
  18
  19 #include "src/smpi/include/private.hpp"
  20
  21 namespace simgrid {
  22 namespace mc {
  23
  24 /** An entry in the functions index
  25  *
  26  *  See the code of ObjectInformation::find_function.
  27  */
  28 struct FunctionIndexEntry {
  29   void* low_pc;
  30   simgrid::mc::Frame* function;
  31 };
  32
  33 /** Information about an ELF module (executable or shared object)
  34  *
  35  *  This contains all the information we need about an executable or
  36  *  shared-object in the model-checked process:
  37  *
  38  *  - where it is located in the virtual address space;
  39  *
  40  *  - where are located its different memory mappings in the the
  41  *    virtual address space;
  42  *
  43  *  - all the debugging (DWARF) information
  44  *    - types,
  45  *    - location of the functions and their local variables,
  46  *    - global variables,
  47  *
  48  *  - etc.
  49  */
  50 class ObjectInformation {
  51   bool dwarf_loaded = false; // Lazily loads the dwarf info
  52
  53 public:
  54   void ensure_dwarf_loaded(); // Used by functions that need the dwarf
  55   ObjectInformation() = default;
  56
  57   // Not copiable:
  58   ObjectInformation(ObjectInformation const&) = delete;
  59   ObjectInformation& operator=(ObjectInformation const&) = delete;
  60
  61   // Flag:
  62   static const int Executable = 1;
  63
  64   /** Bitfield of flags */
  65   int flags = 0;
  66   std::string file_name;
  67   const void* start = nullptr;
  68   const void* end   = nullptr;
  69   // Location of its text segment:
  70   char* start_exec = nullptr;
  71   char* end_exec   = nullptr;
  72   // Location of the read-only part of its data segment:
  73   char* start_rw = nullptr;
  74   char* end_rw   = nullptr;
  75   // Location of the read/write part of its data segment:
  76   char* start_ro = nullptr;
  77   char* end_ro   = nullptr;
  78
  79   /** All of its subprograms indexed by their address */
  80   std::unordered_map<std::uint64_t, simgrid::mc::Frame> subprograms;
  81
  82   /** Index of functions by instruction address
  83    *
  84    * We need to efficiently find the function from any given instruction
  85    * address inside its range. This index is sorted by low_pc
  86    *
  87    * The entries are sorted by low_pc and a binary search can be used to look
  88    * them up. In order to have a better cache locality, we only keep the
  89    * information we need for the lookup in this vector. We could probably
  90    * replace subprograms by an ordered vector of Frame and replace this one b
  91    * a parallel `std::vector<void*>`.
  92    */
  93   std::vector<FunctionIndexEntry> functions_index;
  94
  95   std::vector<simgrid::mc::Variable> global_variables;
  96
  97   /** Types indexed by DWARF ID */
  98   std::unordered_map<std::uint64_t, simgrid::mc::Type> types;
  99
 100   /** Types indexed by name
 101    *
 102    *  Different compilation units have their separate type definitions
 103    *  (for the same type). When we find an opaque type in one compilation unit,
 104    *  we use this in order to try to find its definition in another compilation
 105    *  unit.
 106    */
 107   std::unordered_map<std::string, simgrid::mc::Type*> full_types_by_name;
 108
 109   /** Whether this module is an executable
 110    *
 111    *  More precisely we check if this is an ET_EXE ELF. These ELF files
 112    *  use fixed addresses instead of base-address relative addresses.
 113    *  Position independent executables are in fact ET_DYN.
 114    */
 115   bool executable() const { return this->flags & simgrid::mc::ObjectInformation::Executable; }
 116
 117   /** Base address of the module
 118    *
 119    *  All the location information in ELF and DWARF are expressed as an offsets
 120    *  from this base address:
 121    *
 122    *  - location of the functions and global variables
 123    *
 124    *  - the DWARF instruction `OP_addr` pushes this on the DWARF stack.
 125    **/
 126   void* base_address() const;
 127
 128   /** Find a function by instruction address
 129    *
 130    *  Loads the dwarf information on need.
 131    *
 132    *  @param ip instruction address
 133    *  @return corresponding function (if any) or nullptr
 134    */
 135   simgrid::mc::Frame* find_function(const void* ip);
 136
 137   /** Find a global variable by name
 138    *
 139    *  Loads the dwarf information on need.
 140    *
 141    *  This is used to ignore global variables and to find well-known variables
 142    *  (`__mmalloc_default_mdp`).
 143    *
 144    *  @param name scopes name of the global variable (`myproject::Foo::count`)
 145    *  @return corresponding variable (if any) or nullptr
 146    */
 147   const simgrid::mc::Variable* find_variable(const char* name);
 148
 149   /** Remove a global variable (in order to ignore it)
 150    *
 151    *  This is used to ignore a global variable for the snapshot comparison.
 152    */
 153   void remove_global_variable(const char* name);
 154
 155   /** Remove a local variables (in order to ignore it)
 156    *
 157    *  @param name Name of the local variable
 158    *  @param scope scopes name name of the function (myproject::Foo::count) or null for all functions
 159    */
 160   void remove_local_variable(const char* name, const char* scope);
 161 };
 162
 163 XBT_PRIVATE std::shared_ptr<ObjectInformation> createObjectInformation(std::vector<simgrid::xbt::VmMap> const& maps,
 164                                                                        const char* name);
 165
 166 /** Augment the current module with information about the other ones */
 167 XBT_PRIVATE void postProcessObjectInformation(const simgrid::mc::RemoteProcess* process,
 168                                               simgrid::mc::ObjectInformation* info);
 169 } // namespace mc
 170 } // namespace simgrid
 171
 172 #endif