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 #include <stdint.h>
18
19 #include <memory>
20
21 #include <gtest/gtest.h>
22
23 #include <unwindstack/Elf.h>
24 #include <unwindstack/MachineArm.h>
25 #include <unwindstack/MachineArm64.h>
26 #include <unwindstack/MachineRiscv64.h>
27 #include <unwindstack/MachineX86.h>
28 #include <unwindstack/MachineX86_64.h>
29 #include <unwindstack/RegsArm.h>
30 #include <unwindstack/RegsArm64.h>
31 #include <unwindstack/RegsRiscv64.h>
32 #include <unwindstack/RegsX86.h>
33 #include <unwindstack/RegsX86_64.h>
34
35 #include "utils/MemoryFake.h"
36
37 namespace unwindstack {
38
39 class RegsStepIfSignalHandlerTest : public ::testing::Test {
40 protected:
SetUp()41 void SetUp() override {
42 fake_memory_ = new MemoryFake;
43 std::shared_ptr<Memory> memory(fake_memory_);
44 elf_.reset(new Elf(memory));
45 }
46
47 void ArmStepIfSignalHandlerNonRt(uint32_t pc_data);
48 void ArmStepIfSignalHandlerRt(uint32_t pc_data);
49
50 MemoryFake* fake_memory_;
51 MemoryFake process_memory_;
52 std::unique_ptr<Elf> elf_;
53 };
54
ArmStepIfSignalHandlerNonRt(uint32_t pc_data)55 void RegsStepIfSignalHandlerTest::ArmStepIfSignalHandlerNonRt(uint32_t pc_data) {
56 uint64_t addr = 0x1000;
57 RegsArm regs;
58 regs[ARM_REG_PC] = 0x5000;
59 regs[ARM_REG_SP] = addr;
60
61 fake_memory_->SetData32(0x5000, pc_data);
62
63 for (uint64_t index = 0; index <= 30; index++) {
64 process_memory_.SetData32(addr + index * 4, index * 0x10);
65 }
66
67 ASSERT_TRUE(regs.StepIfSignalHandler(0x5000, elf_.get(), &process_memory_));
68 EXPECT_EQ(0x100U, regs[ARM_REG_SP]);
69 EXPECT_EQ(0x120U, regs[ARM_REG_PC]);
70 EXPECT_EQ(0x100U, regs.sp());
71 EXPECT_EQ(0x120U, regs.pc());
72 }
73
TEST_F(RegsStepIfSignalHandlerTest,arm_step_if_signal_handler_non_rt)74 TEST_F(RegsStepIfSignalHandlerTest, arm_step_if_signal_handler_non_rt) {
75 // Form 1
76 ArmStepIfSignalHandlerNonRt(0xe3a07077);
77
78 // Form 2
79 ArmStepIfSignalHandlerNonRt(0xef900077);
80
81 // Form 3
82 ArmStepIfSignalHandlerNonRt(0xdf002777);
83 }
84
ArmStepIfSignalHandlerRt(uint32_t pc_data)85 void RegsStepIfSignalHandlerTest::ArmStepIfSignalHandlerRt(uint32_t pc_data) {
86 uint64_t addr = 0x1000;
87 RegsArm regs;
88 regs[ARM_REG_PC] = 0x5000;
89 regs[ARM_REG_SP] = addr;
90
91 fake_memory_->SetData32(0x5000, pc_data);
92
93 for (uint64_t index = 0; index <= 100; index++) {
94 process_memory_.SetData32(addr + index * 4, index * 0x10);
95 }
96
97 ASSERT_TRUE(regs.StepIfSignalHandler(0x5000, elf_.get(), &process_memory_));
98 EXPECT_EQ(0x350U, regs[ARM_REG_SP]);
99 EXPECT_EQ(0x370U, regs[ARM_REG_PC]);
100 EXPECT_EQ(0x350U, regs.sp());
101 EXPECT_EQ(0x370U, regs.pc());
102 }
103
TEST_F(RegsStepIfSignalHandlerTest,arm_step_if_signal_handler_rt)104 TEST_F(RegsStepIfSignalHandlerTest, arm_step_if_signal_handler_rt) {
105 // Form 1
106 ArmStepIfSignalHandlerRt(0xe3a070ad);
107
108 // Form 2
109 ArmStepIfSignalHandlerRt(0xef9000ad);
110
111 // Form 3
112 ArmStepIfSignalHandlerRt(0xdf0027ad);
113 }
114
TEST_F(RegsStepIfSignalHandlerTest,arm64_step_if_signal_handler)115 TEST_F(RegsStepIfSignalHandlerTest, arm64_step_if_signal_handler) {
116 uint64_t addr = 0x1000;
117 RegsArm64 regs;
118 regs[ARM64_REG_PC] = 0x8000;
119 regs[ARM64_REG_SP] = addr;
120
121 fake_memory_->SetData64(0x8000, 0xd4000001d2801168ULL);
122
123 for (uint64_t index = 0; index <= 100; index++) {
124 process_memory_.SetData64(addr + index * 8, index * 0x10);
125 }
126
127 ASSERT_TRUE(regs.StepIfSignalHandler(0x8000, elf_.get(), &process_memory_));
128 EXPECT_EQ(0x460U, regs[ARM64_REG_SP]);
129 EXPECT_EQ(0x470U, regs[ARM64_REG_PC]);
130 EXPECT_EQ(0x460U, regs.sp());
131 EXPECT_EQ(0x470U, regs.pc());
132 }
133
TEST_F(RegsStepIfSignalHandlerTest,riscv64_step_if_signal_handler)134 TEST_F(RegsStepIfSignalHandlerTest, riscv64_step_if_signal_handler) {
135 uint64_t addr = 0x1000;
136 RegsRiscv64 regs;
137 regs[RISCV64_REG_PC] = 0x8000;
138 regs[RISCV64_REG_SP] = addr;
139
140 fake_memory_->SetData64(0x8000, 0x0000007308b00893ULL);
141
142 for (uint64_t index = 0; index <= 100; index++) {
143 process_memory_.SetData64(addr + index * 8, index * 0x10);
144 }
145
146 ASSERT_TRUE(regs.StepIfSignalHandler(0x8000, elf_.get(), &process_memory_));
147 EXPECT_EQ(0x280U, regs[RISCV64_REG_SP]);
148 EXPECT_EQ(0x260U, regs[RISCV64_REG_PC]);
149 EXPECT_EQ(0x280U, regs.sp());
150 EXPECT_EQ(0x260U, regs.pc());
151 }
152
TEST_F(RegsStepIfSignalHandlerTest,x86_step_if_signal_handler_no_siginfo)153 TEST_F(RegsStepIfSignalHandlerTest, x86_step_if_signal_handler_no_siginfo) {
154 uint64_t addr = 0xa00;
155 RegsX86 regs;
156 regs[X86_REG_EIP] = 0x4100;
157 regs[X86_REG_ESP] = addr;
158
159 fake_memory_->SetData64(0x4100, 0x80cd00000077b858ULL);
160 for (uint64_t index = 0; index <= 25; index++) {
161 process_memory_.SetData32(addr + index * 4, index * 0x10);
162 }
163
164 ASSERT_TRUE(regs.StepIfSignalHandler(0x4100, elf_.get(), &process_memory_));
165 EXPECT_EQ(0x70U, regs[X86_REG_EBP]);
166 EXPECT_EQ(0x80U, regs[X86_REG_ESP]);
167 EXPECT_EQ(0x90U, regs[X86_REG_EBX]);
168 EXPECT_EQ(0xa0U, regs[X86_REG_EDX]);
169 EXPECT_EQ(0xb0U, regs[X86_REG_ECX]);
170 EXPECT_EQ(0xc0U, regs[X86_REG_EAX]);
171 EXPECT_EQ(0xf0U, regs[X86_REG_EIP]);
172 EXPECT_EQ(0x80U, regs.sp());
173 EXPECT_EQ(0xf0U, regs.pc());
174 }
175
TEST_F(RegsStepIfSignalHandlerTest,x86_step_if_signal_handler_siginfo)176 TEST_F(RegsStepIfSignalHandlerTest, x86_step_if_signal_handler_siginfo) {
177 uint64_t addr = 0xa00;
178 RegsX86 regs;
179 regs[X86_REG_EIP] = 0x4100;
180 regs[X86_REG_ESP] = addr;
181
182 fake_memory_->SetData64(0x4100, 0x0080cd000000adb8ULL);
183 addr += 8;
184 // Pointer to ucontext data.
185 process_memory_.SetData32(addr, 0x8100);
186
187 addr = 0x8100;
188 for (uint64_t index = 0; index <= 30; index++) {
189 process_memory_.SetData32(addr + index * 4, index * 0x10);
190 }
191
192 ASSERT_TRUE(regs.StepIfSignalHandler(0x4100, elf_.get(), &process_memory_));
193 EXPECT_EQ(0xb0U, regs[X86_REG_EBP]);
194 EXPECT_EQ(0xc0U, regs[X86_REG_ESP]);
195 EXPECT_EQ(0xd0U, regs[X86_REG_EBX]);
196 EXPECT_EQ(0xe0U, regs[X86_REG_EDX]);
197 EXPECT_EQ(0xf0U, regs[X86_REG_ECX]);
198 EXPECT_EQ(0x100U, regs[X86_REG_EAX]);
199 EXPECT_EQ(0x130U, regs[X86_REG_EIP]);
200 EXPECT_EQ(0xc0U, regs.sp());
201 EXPECT_EQ(0x130U, regs.pc());
202 }
203
TEST_F(RegsStepIfSignalHandlerTest,x86_64_step_if_signal_handler)204 TEST_F(RegsStepIfSignalHandlerTest, x86_64_step_if_signal_handler) {
205 uint64_t addr = 0x500;
206 RegsX86_64 regs;
207 regs[X86_64_REG_RIP] = 0x7000;
208 regs[X86_64_REG_RSP] = addr;
209
210 fake_memory_->SetData64(0x7000, 0x0f0000000fc0c748);
211 fake_memory_->SetData16(0x7008, 0x0f05);
212
213 for (uint64_t index = 0; index <= 30; index++) {
214 process_memory_.SetData64(addr + index * 8, index * 0x10);
215 }
216
217 ASSERT_TRUE(regs.StepIfSignalHandler(0x7000, elf_.get(), &process_memory_));
218 EXPECT_EQ(0x140U, regs[X86_64_REG_RSP]);
219 EXPECT_EQ(0x150U, regs[X86_64_REG_RIP]);
220 EXPECT_EQ(0x140U, regs.sp());
221 EXPECT_EQ(0x150U, regs.pc());
222 }
223
224 } // namespace unwindstack
225