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 { StepDataStepData36 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 { FunctionDataFunctionData43 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: ElfFake(Memory * memory)51 ElfFake(Memory* memory) : Elf(memory) { valid_ = true; } 52 virtual ~ElfFake() = default; 53 FakeSetValid(bool valid)54 void FakeSetValid(bool valid) { valid_ = valid; } 55 FakeSetLoadBias(uint64_t load_bias)56 void FakeSetLoadBias(uint64_t load_bias) { load_bias_ = load_bias; } 57 FakeSetInterface(ElfInterface * interface)58 void FakeSetInterface(ElfInterface* interface) { interface_.reset(interface); } FakeSetGnuDebugdataInterface(ElfInterface * interface)59 void FakeSetGnuDebugdataInterface(ElfInterface* interface) { 60 gnu_debugdata_interface_.reset(interface); 61 } 62 }; 63 64 class ElfInterfaceFake : public ElfInterface { 65 public: ElfInterfaceFake(Memory * memory)66 ElfInterfaceFake(Memory* memory) : ElfInterface(memory) {} 67 virtual ~ElfInterfaceFake() = default; 68 Init(uint64_t *)69 bool Init(uint64_t*) override { return false; } InitHeaders()70 void InitHeaders() override {} GetSoname(std::string *)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 FakeSetGlobalVariable(const std::string & global,uint64_t offset)78 void FakeSetGlobalVariable(const std::string& global, uint64_t offset) { 79 globals_[global] = offset; 80 } 81 FakePushFunctionData(const FunctionData data)82 static void FakePushFunctionData(const FunctionData data) { functions_.push_back(data); } FakePushStepData(const StepData data)83 static void FakePushStepData(const StepData data) { steps_.push_back(data); } 84 FakeClear()85 static void FakeClear() { 86 functions_.clear(); 87 steps_.clear(); 88 } 89 FakeSetErrorCode(ErrorCode code)90 void FakeSetErrorCode(ErrorCode code) { last_error_.code = code; } 91 FakeSetErrorAddress(uint64_t address)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: ElfInterface32Fake(Memory * memory)103 ElfInterface32Fake(Memory* memory) : ElfInterface32(memory) {} 104 virtual ~ElfInterface32Fake() = default; 105 FakeSetEhFrameOffset(uint64_t offset)106 void FakeSetEhFrameOffset(uint64_t offset) { eh_frame_offset_ = offset; } FakeSetEhFrameSize(uint64_t size)107 void FakeSetEhFrameSize(uint64_t size) { eh_frame_size_ = size; } FakeSetDebugFrameOffset(uint64_t offset)108 void FakeSetDebugFrameOffset(uint64_t offset) { debug_frame_offset_ = offset; } FakeSetDebugFrameSize(uint64_t size)109 void FakeSetDebugFrameSize(uint64_t size) { debug_frame_size_ = size; } 110 }; 111 112 class ElfInterface64Fake : public ElfInterface64 { 113 public: ElfInterface64Fake(Memory * memory)114 ElfInterface64Fake(Memory* memory) : ElfInterface64(memory) {} 115 virtual ~ElfInterface64Fake() = default; 116 FakeSetEhFrameOffset(uint64_t offset)117 void FakeSetEhFrameOffset(uint64_t offset) { eh_frame_offset_ = offset; } FakeSetEhFrameSize(uint64_t size)118 void FakeSetEhFrameSize(uint64_t size) { eh_frame_size_ = size; } FakeSetDebugFrameOffset(uint64_t offset)119 void FakeSetDebugFrameOffset(uint64_t offset) { debug_frame_offset_ = offset; } FakeSetDebugFrameSize(uint64_t size)120 void FakeSetDebugFrameSize(uint64_t size) { debug_frame_size_ = size; } 121 }; 122 123 class ElfInterfaceArmFake : public ElfInterfaceArm { 124 public: ElfInterfaceArmFake(Memory * memory)125 ElfInterfaceArmFake(Memory* memory) : ElfInterfaceArm(memory) {} 126 virtual ~ElfInterfaceArmFake() = default; 127 FakeSetStartOffset(uint64_t offset)128 void FakeSetStartOffset(uint64_t offset) { start_offset_ = offset; } FakeSetTotalEntries(size_t entries)129 void FakeSetTotalEntries(size_t entries) { total_entries_ = entries; } 130 }; 131 132 } // namespace unwindstack 133 134 #endif // _LIBUNWINDSTACK_TESTS_ELF_FAKE_H 135