1 /* 2 * Copyright (C) 2017 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 #ifndef _LIBUNWINDSTACK_TESTS_ELF_FAKE_H 18 #define _LIBUNWINDSTACK_TESTS_ELF_FAKE_H 19 20 #include <stdint.h> 21 22 #include <deque> 23 #include <string> 24 #include <unordered_map> 25 26 #include <unwindstack/Elf.h> 27 #include <unwindstack/ElfInterface.h> 28 #include <unwindstack/Memory.h> 29 #include <unwindstack/Regs.h> 30 31 #include "ElfInterfaceArm.h" 32 33 namespace unwindstack { 34 35 struct StepData { 36 StepData(uint64_t pc, uint64_t sp, bool finished) : pc(pc), sp(sp), finished(finished) {} 37 uint64_t pc; 38 uint64_t sp; 39 bool finished; 40 }; 41 42 struct FunctionData { 43 FunctionData(std::string name, uint64_t offset) : name(name), offset(offset) {} 44 45 std::string name; 46 uint64_t offset; 47 }; 48 49 class ElfFake : public Elf { 50 public: 51 ElfFake(Memory* memory) : Elf(memory) { valid_ = true; } 52 virtual ~ElfFake() = default; 53 54 void FakeSetValid(bool valid) { valid_ = valid; } 55 56 void FakeSetLoadBias(uint64_t load_bias) { load_bias_ = load_bias; } 57 58 void FakeSetInterface(ElfInterface* interface) { interface_.reset(interface); } 59 void FakeSetGnuDebugdataInterface(ElfInterface* interface) { 60 gnu_debugdata_interface_.reset(interface); 61 } 62 }; 63 64 class ElfInterfaceFake : public ElfInterface { 65 public: 66 ElfInterfaceFake(Memory* memory) : ElfInterface(memory) {} 67 virtual ~ElfInterfaceFake() = default; 68 69 bool Init(uint64_t*) override { return false; } 70 void InitHeaders() override {} 71 bool GetSoname(std::string*) override { return false; } 72 73 bool GetFunctionName(uint64_t, uint64_t, std::string*, uint64_t*) override; 74 bool GetGlobalVariable(const std::string&, uint64_t*) override; 75 76 bool Step(uint64_t, uint64_t, Regs*, Memory*, bool*) override; 77 78 void FakeSetGlobalVariable(const std::string& global, uint64_t offset) { 79 globals_[global] = offset; 80 } 81 82 static void FakePushFunctionData(const FunctionData data) { functions_.push_back(data); } 83 static void FakePushStepData(const StepData data) { steps_.push_back(data); } 84 85 static void FakeClear() { 86 functions_.clear(); 87 steps_.clear(); 88 } 89 90 void FakeSetErrorCode(ErrorCode code) { last_error_.code = code; } 91 92 void FakeSetErrorAddress(uint64_t address) { last_error_.address = address; } 93 94 private: 95 std::unordered_map<std::string, uint64_t> globals_; 96 97 static std::deque<FunctionData> functions_; 98 static std::deque<StepData> steps_; 99 }; 100 101 class ElfInterface32Fake : public ElfInterface32 { 102 public: 103 ElfInterface32Fake(Memory* memory) : ElfInterface32(memory) {} 104 virtual ~ElfInterface32Fake() = default; 105 106 void FakeSetEhFrameOffset(uint64_t offset) { eh_frame_offset_ = offset; } 107 void FakeSetEhFrameSize(uint64_t size) { eh_frame_size_ = size; } 108 void FakeSetDebugFrameOffset(uint64_t offset) { debug_frame_offset_ = offset; } 109 void FakeSetDebugFrameSize(uint64_t size) { debug_frame_size_ = size; } 110 }; 111 112 class ElfInterface64Fake : public ElfInterface64 { 113 public: 114 ElfInterface64Fake(Memory* memory) : ElfInterface64(memory) {} 115 virtual ~ElfInterface64Fake() = default; 116 117 void FakeSetEhFrameOffset(uint64_t offset) { eh_frame_offset_ = offset; } 118 void FakeSetEhFrameSize(uint64_t size) { eh_frame_size_ = size; } 119 void FakeSetDebugFrameOffset(uint64_t offset) { debug_frame_offset_ = offset; } 120 void FakeSetDebugFrameSize(uint64_t size) { debug_frame_size_ = size; } 121 }; 122 123 class ElfInterfaceArmFake : public ElfInterfaceArm { 124 public: 125 ElfInterfaceArmFake(Memory* memory) : ElfInterfaceArm(memory) {} 126 virtual ~ElfInterfaceArmFake() = default; 127 128 void FakeSetStartOffset(uint64_t offset) { start_offset_ = offset; } 129 void FakeSetTotalEntries(size_t entries) { total_entries_ = entries; } 130 }; 131 132 } // namespace unwindstack 133 134 #endif // _LIBUNWINDSTACK_TESTS_ELF_FAKE_H 135