2020-09-13 21:32:55 -04:00
|
|
|
#pragma once
|
|
|
|
|
2020-08-22 23:30:17 -04:00
|
|
|
/*!
|
|
|
|
* @file ObjectFileDB.h
|
|
|
|
* A "database" of object files found in DGO files.
|
|
|
|
* Eliminates duplicate object files, and also assigns unique names to all object files
|
|
|
|
* (there may be different object files with the same name sometimes)
|
|
|
|
*/
|
|
|
|
|
2021-05-10 23:03:56 -04:00
|
|
|
#include "common/util/assert.h"
|
2020-08-22 23:30:17 -04:00
|
|
|
#include <string>
|
|
|
|
#include <unordered_map>
|
|
|
|
#include <vector>
|
|
|
|
#include "LinkedObjectFile.h"
|
2020-09-29 20:24:15 -04:00
|
|
|
#include "decompiler/util/DecompilerTypeSystem.h"
|
2020-10-29 21:27:52 -04:00
|
|
|
#include "common/common_types.h"
|
2020-08-22 23:30:17 -04:00
|
|
|
|
2021-01-06 20:04:15 -05:00
|
|
|
namespace decompiler {
|
2020-08-22 23:30:17 -04:00
|
|
|
/*!
|
|
|
|
* A "record" which can be used to identify an object file.
|
|
|
|
*/
|
|
|
|
struct ObjectFileRecord {
|
2020-10-24 14:27:50 -04:00
|
|
|
std::string name; // including -ag, not including dgo suffix
|
2020-08-22 23:30:17 -04:00
|
|
|
int version = -1;
|
|
|
|
uint32_t hash = 0;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*!
|
|
|
|
* All of the data for a single object file
|
|
|
|
*/
|
|
|
|
struct ObjectFileData {
|
|
|
|
std::vector<uint8_t> data; // raw bytes
|
|
|
|
LinkedObjectFile linked_data; // data including linking annotations
|
|
|
|
ObjectFileRecord record; // name
|
2020-09-03 20:11:31 -04:00
|
|
|
std::vector<std::string> dgo_names;
|
|
|
|
int obj_version = -1;
|
|
|
|
bool has_multiple_versions = false;
|
|
|
|
std::string name_in_dgo;
|
2020-10-24 14:27:50 -04:00
|
|
|
std::string name_from_map;
|
2020-09-03 20:11:31 -04:00
|
|
|
std::string to_unique_name() const;
|
2020-08-22 23:30:17 -04:00
|
|
|
uint32_t reference_count = 0; // number of times its used.
|
|
|
|
};
|
|
|
|
|
|
|
|
class ObjectFileDB {
|
|
|
|
public:
|
2020-11-19 21:22:16 -05:00
|
|
|
ObjectFileDB(const std::vector<std::string>& _dgos,
|
|
|
|
const std::string& obj_file_name_map_file,
|
2020-11-21 15:58:51 -05:00
|
|
|
const std::vector<std::string>& object_files,
|
2021-05-11 20:49:54 -04:00
|
|
|
const std::vector<std::string>& str_files,
|
|
|
|
const Config& config);
|
2020-08-22 23:30:17 -04:00
|
|
|
std::string generate_dgo_listing();
|
2020-09-03 20:11:31 -04:00
|
|
|
std::string generate_obj_listing();
|
2021-05-11 20:49:54 -04:00
|
|
|
void process_link_data(const Config& config);
|
2020-08-22 23:30:17 -04:00
|
|
|
void process_labels();
|
2021-05-11 20:49:54 -04:00
|
|
|
void find_code(const Config& config);
|
2020-08-22 23:30:17 -04:00
|
|
|
void find_and_write_scripts(const std::string& output_dir);
|
2020-11-24 20:48:38 -05:00
|
|
|
void dump_raw_objects(const std::string& output_dir);
|
2020-08-22 23:30:17 -04:00
|
|
|
|
2021-05-11 19:19:23 -04:00
|
|
|
void write_object_file_words(const std::string& output_dir, bool dump_data, bool dump_code);
|
2020-11-27 16:38:36 -05:00
|
|
|
void write_disassembly(const std::string& output_dir,
|
2021-05-11 19:19:23 -04:00
|
|
|
bool disassemble_data,
|
2021-05-11 20:49:54 -04:00
|
|
|
bool disassemble_code,
|
|
|
|
bool print_hex);
|
2020-11-27 16:38:36 -05:00
|
|
|
|
2021-05-11 20:49:54 -04:00
|
|
|
void analyze_functions_ir1(const Config& config);
|
2021-07-11 16:35:25 -04:00
|
|
|
void analyze_functions_ir2(const std::string& output_dir,
|
|
|
|
const Config& config,
|
|
|
|
bool skip_debug_output = false);
|
2021-05-11 20:49:54 -04:00
|
|
|
void ir2_top_level_pass(const Config& config);
|
2021-04-25 14:48:54 -04:00
|
|
|
void ir2_stack_spill_slot_pass();
|
2021-05-24 19:52:19 -04:00
|
|
|
void ir2_basic_block_pass(const Config& config);
|
2021-05-11 20:49:54 -04:00
|
|
|
void ir2_atomic_op_pass(const Config& config);
|
|
|
|
void ir2_type_analysis_pass(const Config& config);
|
2021-01-12 19:20:08 -05:00
|
|
|
void ir2_register_usage_pass();
|
2021-01-16 10:54:09 -05:00
|
|
|
void ir2_variable_pass();
|
2021-01-17 18:08:18 -05:00
|
|
|
void ir2_cfg_build_pass();
|
2021-01-22 20:50:37 -05:00
|
|
|
void ir2_store_current_forms();
|
2021-05-11 20:49:54 -04:00
|
|
|
void ir2_build_expressions(const Config& config);
|
2021-03-05 18:48:01 -05:00
|
|
|
void ir2_insert_lets();
|
2021-03-06 10:46:26 -05:00
|
|
|
void ir2_rewrite_inline_asm_instructions();
|
2021-03-14 19:06:51 -04:00
|
|
|
void ir2_insert_anonymous_functions();
|
2021-05-31 10:43:25 -04:00
|
|
|
void ir2_symbol_definition_map(const std::string& output_dir);
|
2021-05-24 19:52:19 -04:00
|
|
|
void ir2_write_results(const std::string& output_dir, const Config& config);
|
|
|
|
std::string ir2_to_file(ObjectFileData& data, const Config& config);
|
2021-01-09 20:01:48 -05:00
|
|
|
std::string ir2_function_to_string(ObjectFileData& data, Function& function, int seg);
|
2021-03-03 15:42:55 -05:00
|
|
|
std::string ir2_final_out(ObjectFileData& data,
|
|
|
|
const std::unordered_set<std::string>& skip_functions = {});
|
2021-01-09 20:01:48 -05:00
|
|
|
|
2021-07-02 14:50:58 -04:00
|
|
|
std::string process_tpages();
|
2021-01-06 20:04:15 -05:00
|
|
|
std::string process_game_count_file();
|
|
|
|
std::string process_game_text_files();
|
2020-11-16 19:57:45 -05:00
|
|
|
|
2020-10-24 14:27:50 -04:00
|
|
|
ObjectFileData& lookup_record(const ObjectFileRecord& rec);
|
2020-09-29 20:24:15 -04:00
|
|
|
DecompilerTypeSystem dts;
|
2020-10-24 22:51:40 -04:00
|
|
|
std::string all_type_defs;
|
2020-08-22 23:30:17 -04:00
|
|
|
|
2021-01-10 20:46:49 -05:00
|
|
|
bool lookup_function_type(const FunctionName& name,
|
|
|
|
const std::string& obj_name,
|
2021-05-11 20:49:54 -04:00
|
|
|
const Config& config,
|
2021-01-10 20:46:49 -05:00
|
|
|
TypeSpec* result);
|
|
|
|
|
2021-02-06 09:54:23 -05:00
|
|
|
public:
|
2020-10-24 14:27:50 -04:00
|
|
|
void load_map_file(const std::string& map_data);
|
2021-05-11 20:49:54 -04:00
|
|
|
void get_objs_from_dgo(const std::string& filename, const Config& config);
|
2020-08-22 23:30:17 -04:00
|
|
|
void add_obj_from_dgo(const std::string& obj_name,
|
2020-09-03 20:11:31 -04:00
|
|
|
const std::string& name_in_dgo,
|
2020-11-21 15:58:51 -05:00
|
|
|
const uint8_t* obj_data,
|
2020-08-22 23:30:17 -04:00
|
|
|
uint32_t obj_size,
|
2021-05-11 20:49:54 -04:00
|
|
|
const std::string& dgo_name,
|
|
|
|
const Config& config);
|
2020-08-22 23:30:17 -04:00
|
|
|
|
|
|
|
/*!
|
|
|
|
* Apply f to all ObjectFileData's. Does it in the right order.
|
|
|
|
*/
|
|
|
|
template <typename Func>
|
|
|
|
void for_each_obj(Func f) {
|
|
|
|
assert(obj_files_by_name.size() == obj_file_order.size());
|
2020-08-26 01:21:33 -04:00
|
|
|
for (const auto& name : obj_file_order) {
|
|
|
|
for (auto& obj : obj_files_by_name.at(name)) {
|
2020-08-22 23:30:17 -04:00
|
|
|
f(obj);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
|
|
* Apply f to all functions
|
|
|
|
* takes (Function, segment, linked_data)
|
|
|
|
* Does it in the right order.
|
|
|
|
*/
|
|
|
|
template <typename Func>
|
|
|
|
void for_each_function(Func f) {
|
|
|
|
for_each_obj([&](ObjectFileData& data) {
|
|
|
|
for (int i = 0; i < int(data.linked_data.segments); i++) {
|
|
|
|
int fn = 0;
|
|
|
|
for (auto& goal_func : data.linked_data.functions_by_seg.at(i)) {
|
|
|
|
f(goal_func, i, data);
|
|
|
|
fn++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2020-10-24 22:51:40 -04:00
|
|
|
template <typename Func>
|
|
|
|
void for_each_function_def_order(Func f) {
|
|
|
|
for_each_obj([&](ObjectFileData& data) {
|
|
|
|
for (int i = 0; i < int(data.linked_data.segments); i++) {
|
|
|
|
int fn = 0;
|
|
|
|
for (size_t j = data.linked_data.functions_by_seg.at(i).size(); j-- > 0;) {
|
|
|
|
f(data.linked_data.functions_by_seg.at(i).at(j), i, data);
|
|
|
|
fn++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2020-08-22 23:30:17 -04:00
|
|
|
// Danger: after adding all object files, we assume that the vector never reallocates.
|
|
|
|
std::unordered_map<std::string, std::vector<ObjectFileData>> obj_files_by_name;
|
|
|
|
std::unordered_map<std::string, std::vector<ObjectFileRecord>> obj_files_by_dgo;
|
|
|
|
|
|
|
|
std::vector<std::string> obj_file_order;
|
2020-10-24 14:27:50 -04:00
|
|
|
std::unordered_map<std::string, std::unordered_map<std::string, std::string>> dgo_obj_name_map;
|
2020-08-22 23:30:17 -04:00
|
|
|
|
|
|
|
struct {
|
|
|
|
uint32_t total_dgo_bytes = 0;
|
|
|
|
uint32_t total_obj_files = 0;
|
|
|
|
uint32_t unique_obj_files = 0;
|
|
|
|
uint32_t unique_obj_bytes = 0;
|
|
|
|
} stats;
|
|
|
|
};
|
2021-01-06 20:04:15 -05:00
|
|
|
} // namespace decompiler
|