OLD | NEW |
---|---|
1 // Copyright 2014 The Crashpad Authors. All rights reserved. | 1 // Copyright 2014 The Crashpad Authors. All rights reserved. |
2 // | 2 // |
3 // Licensed under the Apache License, Version 2.0 (the "License"); | 3 // Licensed under the Apache License, Version 2.0 (the "License"); |
4 // you may not use this file except in compliance with the License. | 4 // you may not use this file except in compliance with the License. |
5 // You may obtain a copy of the License at | 5 // You may obtain a copy of the License at |
6 // | 6 // |
7 // http://www.apache.org/licenses/LICENSE-2.0 | 7 // http://www.apache.org/licenses/LICENSE-2.0 |
8 // | 8 // |
9 // Unless required by applicable law or agreed to in writing, software | 9 // Unless required by applicable law or agreed to in writing, software |
10 // distributed under the License is distributed on an "AS IS" BASIS, | 10 // distributed under the License is distributed on an "AS IS" BASIS, |
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
12 // See the License for the specific language governing permissions and | 12 // See the License for the specific language governing permissions and |
13 // limitations under the License. | 13 // limitations under the License. |
14 | 14 |
15 #include "minidump/test/minidump_context_test_util.h" | 15 #include "minidump/test/minidump_context_test_util.h" |
16 | 16 |
17 #include "base/basictypes.h" | 17 #include "base/basictypes.h" |
18 #include "base/strings/stringprintf.h" | |
18 #include "gtest/gtest.h" | 19 #include "gtest/gtest.h" |
20 #include "snapshot/cpu_context.h" | |
21 #include "snapshot/test/test_cpu_context.h" | |
19 | 22 |
20 namespace crashpad { | 23 namespace crashpad { |
21 namespace test { | 24 namespace test { |
22 | 25 |
23 void InitializeMinidumpContextX86(MinidumpContextX86* context, uint32_t seed) { | 26 void InitializeMinidumpContextX86(MinidumpContextX86* context, uint32_t seed) { |
24 if (seed == 0) { | 27 if (seed == 0) { |
25 memset(context, 0, sizeof(*context)); | 28 memset(context, 0, sizeof(*context)); |
26 context->context_flags = kMinidumpContextX86; | 29 context->context_flags = kMinidumpContextX86; |
27 return; | 30 return; |
28 } | 31 } |
29 | 32 |
30 context->context_flags = kMinidumpContextX86All; | 33 context->context_flags = kMinidumpContextX86All; |
31 | 34 |
32 uint32_t value = seed; | 35 uint32_t value = seed; |
33 | 36 |
37 context->eax = value++; | |
38 context->ebx = value++; | |
39 context->ecx = value++; | |
40 context->edx = value++; | |
41 context->edi = value++; | |
42 context->esi = value++; | |
43 context->ebp = value++; | |
44 context->esp = value++; | |
45 context->eip = value++; | |
46 context->eflags = value++; | |
47 context->cs = value++ & 0xffff; | |
48 context->ds = value++ & 0xffff; | |
49 context->es = value++ & 0xffff; | |
50 context->fs = value++ & 0xffff; | |
51 context->gs = value++ & 0xffff; | |
52 context->ss = value++ & 0xffff; | |
53 | |
54 InitializeCPUContextX86Fxsave(&context->fxsave, &value); | |
55 | |
34 context->dr0 = value++; | 56 context->dr0 = value++; |
35 context->dr1 = value++; | 57 context->dr1 = value++; |
36 context->dr2 = value++; | 58 context->dr2 = value++; |
37 context->dr3 = value++; | 59 context->dr3 = value++; |
60 value += 2; // Minidumps don’t carry dr4 or dr5. | |
Robert Sesek
2014/11/03 21:26:57
This comment may be useful in the header that defi
Mark Mentovai
2014/11/03 22:01:21
Robert Sesek wrote:
Robert Sesek
2014/11/03 22:22:06
In addition, as you've done.
| |
38 context->dr6 = value++; | 61 context->dr6 = value++; |
39 context->dr7 = value++; | 62 context->dr7 = value++; |
40 context->float_save.control_word = value++; | 63 |
41 context->float_save.status_word = value++; | 64 // Copy the values that are aliased between the fxsave area |
42 context->float_save.tag_word = value++; | 65 // (context->extended_registers) and the floating-point save area |
43 context->float_save.error_offset = value++; | 66 // (context->float_save). |
44 context->float_save.error_selector = value++; | 67 context->float_save.control_word = context->fxsave.fcw; |
45 context->float_save.data_offset = value++; | 68 context->float_save.status_word = context->fxsave.fsw; |
46 context->float_save.data_selector = value++; | 69 context->float_save.tag_word = CPUContextX86::FxsaveToFsaveTagWord( |
47 for (size_t index = 0; | 70 context->fxsave.fsw, context->fxsave.ftw, context->fxsave.st_mm); |
48 index < arraysize(context->float_save.register_area); | 71 context->float_save.error_offset = context->fxsave.fpu_ip; |
49 ++index) { | 72 context->float_save.error_selector = context->fxsave.fpu_cs; |
50 context->float_save.register_area[index] = value++; | 73 context->float_save.data_offset = context->fxsave.fpu_dp; |
74 context->float_save.data_selector = context->fxsave.fpu_ds; | |
75 for (size_t st_mm_index = 0; | |
76 st_mm_index < arraysize(context->fxsave.st_mm); | |
77 ++st_mm_index) { | |
78 for (size_t byte = 0; | |
79 byte < arraysize(context->fxsave.st_mm[st_mm_index].st); | |
80 ++byte) { | |
81 size_t st_index = | |
82 st_mm_index * arraysize(context->fxsave.st_mm[st_mm_index].st) + byte; | |
83 context->float_save.register_area[st_index] = | |
84 context->fxsave.st_mm[st_mm_index].st[byte]; | |
85 } | |
51 } | 86 } |
87 | |
88 // Set this field last, because it has no analogue in CPUContextX86. | |
52 context->float_save.spare_0 = value++; | 89 context->float_save.spare_0 = value++; |
53 context->gs = value++; | |
54 context->fs = value++; | |
55 context->es = value++; | |
56 context->ds = value++; | |
57 context->edi = value++; | |
58 context->esi = value++; | |
59 context->ebx = value++; | |
60 context->edx = value++; | |
61 context->ecx = value++; | |
62 context->eax = value++; | |
63 context->ebp = value++; | |
64 context->eip = value++; | |
65 context->cs = value++; | |
66 context->eflags = value++; | |
67 context->esp = value++; | |
68 context->ss = value++; | |
69 for (size_t index = 0; index < arraysize(context->extended_registers); | |
70 ++index) { | |
71 context->extended_registers[index] = value++; | |
72 } | |
73 } | 90 } |
74 | 91 |
75 void InitializeMinidumpContextAMD64(MinidumpContextAMD64* context, | 92 void InitializeMinidumpContextAMD64(MinidumpContextAMD64* context, |
76 uint32_t seed) { | 93 uint32_t seed) { |
77 if (seed == 0) { | 94 if (seed == 0) { |
78 memset(context, 0, sizeof(*context)); | 95 memset(context, 0, sizeof(*context)); |
79 context->context_flags = kMinidumpContextAMD64; | 96 context->context_flags = kMinidumpContextAMD64; |
80 return; | 97 return; |
81 } | 98 } |
82 | 99 |
83 context->context_flags = kMinidumpContextAMD64All; | 100 context->context_flags = kMinidumpContextAMD64All; |
84 | 101 |
85 uint32_t value = seed; | 102 uint32_t value = seed; |
86 | 103 |
87 context->p1_home = value++; | |
88 context->p2_home = value++; | |
89 context->p3_home = value++; | |
90 context->p4_home = value++; | |
91 context->p5_home = value++; | |
92 context->p6_home = value++; | |
93 context->mx_csr = value++; | |
94 context->cs = value++; | |
95 context->ds = value++; | |
96 context->es = value++; | |
97 context->fs = value++; | |
98 context->gs = value++; | |
99 context->ss = value++; | |
100 context->eflags = value++; | |
101 context->dr0 = value++; | |
102 context->dr1 = value++; | |
103 context->dr2 = value++; | |
104 context->dr3 = value++; | |
105 context->dr6 = value++; | |
106 context->dr7 = value++; | |
107 context->rax = value++; | 104 context->rax = value++; |
105 context->rbx = value++; | |
108 context->rcx = value++; | 106 context->rcx = value++; |
109 context->rdx = value++; | 107 context->rdx = value++; |
110 context->rbx = value++; | 108 context->rdi = value++; |
109 context->rsi = value++; | |
110 context->rbp = value++; | |
111 context->rsp = value++; | 111 context->rsp = value++; |
112 context->rbp = value++; | |
113 context->rsi = value++; | |
114 context->rdi = value++; | |
115 context->r8 = value++; | 112 context->r8 = value++; |
116 context->r9 = value++; | 113 context->r9 = value++; |
117 context->r10 = value++; | 114 context->r10 = value++; |
118 context->r11 = value++; | 115 context->r11 = value++; |
119 context->r12 = value++; | 116 context->r12 = value++; |
120 context->r13 = value++; | 117 context->r13 = value++; |
121 context->r14 = value++; | 118 context->r14 = value++; |
122 context->r15 = value++; | 119 context->r15 = value++; |
123 context->rip = value++; | 120 context->rip = value++; |
124 context->float_save.control_word = value++; | 121 context->eflags = value++; |
125 context->float_save.status_word = value++; | 122 context->cs = value++; |
126 context->float_save.tag_word = value++; | 123 context->fs = value++; |
127 context->float_save.reserved_1 = value++; | 124 context->gs = value++; |
128 context->float_save.error_opcode = value++; | 125 |
129 context->float_save.error_offset = value++; | 126 InitializeCPUContextX86_64Fxsave(&context->fxsave, &value); |
130 context->float_save.error_selector = value++; | 127 |
131 context->float_save.reserved_2 = value++; | 128 // mxcsr appears twice, and the two values should be aliased. |
132 context->float_save.data_offset = value++; | 129 context->mx_csr = context->fxsave.mxcsr; |
133 context->float_save.data_selector = value++; | 130 |
134 context->float_save.reserved_3 = value++; | 131 context->dr0 = value++; |
135 context->float_save.mx_csr = value++; | 132 context->dr1 = value++; |
136 context->float_save.mx_csr_mask = value++; | 133 context->dr2 = value++; |
137 for (size_t index = 0; | 134 context->dr3 = value++; |
138 index < arraysize(context->float_save.float_registers); | 135 value += 2; // Minidumps don’t carry dr4 or dr5. |
139 ++index) { | 136 context->dr6 = value++; |
140 context->float_save.float_registers[index].lo = value++; | 137 context->dr7 = value++; |
141 context->float_save.float_registers[index].hi = value++; | 138 |
142 } | 139 // Set these fields last, because they have no analogues in CPUContextX86_64. |
143 for (size_t index = 0; | 140 context->p1_home = value++; |
144 index < arraysize(context->float_save.xmm_registers); | 141 context->p2_home = value++; |
145 ++index) { | 142 context->p3_home = value++; |
146 context->float_save.xmm_registers[index].lo = value++; | 143 context->p4_home = value++; |
147 context->float_save.xmm_registers[index].hi = value++; | 144 context->p5_home = value++; |
148 } | 145 context->p6_home = value++; |
149 for (size_t index = 0; | 146 context->ds = value++; |
150 index < arraysize(context->float_save.reserved_4); | 147 context->es = value++; |
151 ++index) { | 148 context->ss = value++; |
152 context->float_save.reserved_4[index] = value++; | |
153 } | |
154 for (size_t index = 0; index < arraysize(context->vector_register); ++index) { | 149 for (size_t index = 0; index < arraysize(context->vector_register); ++index) { |
155 context->vector_register[index].lo = value++; | 150 context->vector_register[index].lo = value++; |
156 context->vector_register[index].hi = value++; | 151 context->vector_register[index].hi = value++; |
157 } | 152 } |
158 context->vector_control = value++; | 153 context->vector_control = value++; |
159 context->debug_control = value++; | 154 context->debug_control = value++; |
160 context->last_branch_to_rip = value++; | 155 context->last_branch_to_rip = value++; |
161 context->last_branch_from_rip = value++; | 156 context->last_branch_from_rip = value++; |
162 context->last_exception_to_rip = value++; | 157 context->last_exception_to_rip = value++; |
163 context->last_exception_from_rip = value++; | 158 context->last_exception_from_rip = value++; |
164 } | 159 } |
165 | 160 |
166 void ExpectMinidumpContextX86(uint32_t expect_seed, | 161 namespace { |
167 const MinidumpContextX86* observed) { | 162 |
163 // Using gtest assertions, compares |expected| to |observed|. This is | |
164 // templatized because the CPUContextX86::Fxsave and CPUContextX86_64::Fxsave | |
165 // are nearly identical but have different sizes for the members |xmm|, | |
166 // |reserved_4|, and |available|. | |
167 template <typename FxsaveType> | |
168 void ExpectMinidumpContextFxsave(const FxsaveType* expected, | |
169 const FxsaveType* observed) { | |
170 EXPECT_EQ(expected->fcw, observed->fcw); | |
171 EXPECT_EQ(expected->fsw, observed->fsw); | |
172 EXPECT_EQ(expected->ftw, observed->ftw); | |
173 EXPECT_EQ(expected->reserved_1, observed->reserved_1); | |
174 EXPECT_EQ(expected->fop, observed->fop); | |
175 EXPECT_EQ(expected->fpu_ip, observed->fpu_ip); | |
176 EXPECT_EQ(expected->fpu_cs, observed->fpu_cs); | |
177 EXPECT_EQ(expected->reserved_2, observed->reserved_2); | |
178 EXPECT_EQ(expected->fpu_dp, observed->fpu_dp); | |
179 EXPECT_EQ(expected->fpu_ds, observed->fpu_ds); | |
180 EXPECT_EQ(expected->reserved_3, observed->reserved_3); | |
181 EXPECT_EQ(expected->mxcsr, observed->mxcsr); | |
182 EXPECT_EQ(expected->mxcsr_mask, observed->mxcsr_mask); | |
183 for (size_t st_mm_index = 0; | |
184 st_mm_index < arraysize(expected->st_mm); | |
185 ++st_mm_index) { | |
186 SCOPED_TRACE(base::StringPrintf("st_mm_index %zu", st_mm_index)); | |
187 for (size_t byte = 0; | |
188 byte < arraysize(expected->st_mm[st_mm_index].st); | |
189 ++byte) { | |
190 EXPECT_EQ(expected->st_mm[st_mm_index].st[byte], | |
191 observed->st_mm[st_mm_index].st[byte]) << "byte " << byte; | |
192 } | |
193 for (size_t byte = 0; | |
194 byte < arraysize(expected->st_mm[st_mm_index].st_reserved); | |
195 ++byte) { | |
196 EXPECT_EQ(expected->st_mm[st_mm_index].st_reserved[byte], | |
197 observed->st_mm[st_mm_index].st_reserved[byte]) | |
198 << "byte " << byte; | |
199 } | |
200 } | |
201 for (size_t xmm_index = 0; | |
202 xmm_index < arraysize(expected->xmm); | |
203 ++xmm_index) { | |
204 SCOPED_TRACE(base::StringPrintf("xmm_index %zu", xmm_index)); | |
205 for (size_t byte = 0; byte < arraysize(expected->xmm[xmm_index]); ++byte) { | |
206 EXPECT_EQ(expected->xmm[xmm_index][byte], observed->xmm[xmm_index][byte]) | |
207 << "byte " << byte; | |
208 } | |
209 } | |
210 for (size_t byte = 0; byte < arraysize(expected->reserved_4); ++byte) { | |
211 EXPECT_EQ(expected->reserved_4[byte], observed->reserved_4[byte]) | |
212 << "byte " << byte; | |
213 } | |
214 for (size_t byte = 0; byte < arraysize(expected->available); ++byte) { | |
215 EXPECT_EQ(expected->available[byte], observed->available[byte]) | |
216 << "byte " << byte; | |
217 } | |
218 } | |
219 | |
220 } // namespace | |
221 | |
222 void ExpectMinidumpContextX86( | |
223 uint32_t expect_seed, const MinidumpContextX86* observed, bool snapshot) { | |
168 MinidumpContextX86 expected; | 224 MinidumpContextX86 expected; |
169 InitializeMinidumpContextX86(&expected, expect_seed); | 225 InitializeMinidumpContextX86(&expected, expect_seed); |
170 | 226 |
171 EXPECT_EQ(expected.context_flags, observed->context_flags); | 227 EXPECT_EQ(expected.context_flags, observed->context_flags); |
172 EXPECT_EQ(expected.dr0, observed->dr0); | 228 EXPECT_EQ(expected.dr0, observed->dr0); |
173 EXPECT_EQ(expected.dr1, observed->dr1); | 229 EXPECT_EQ(expected.dr1, observed->dr1); |
174 EXPECT_EQ(expected.dr2, observed->dr2); | 230 EXPECT_EQ(expected.dr2, observed->dr2); |
175 EXPECT_EQ(expected.dr3, observed->dr3); | 231 EXPECT_EQ(expected.dr3, observed->dr3); |
176 EXPECT_EQ(expected.dr6, observed->dr6); | 232 EXPECT_EQ(expected.dr6, observed->dr6); |
177 EXPECT_EQ(expected.dr7, observed->dr7); | 233 EXPECT_EQ(expected.dr7, observed->dr7); |
234 | |
178 EXPECT_EQ(expected.float_save.control_word, | 235 EXPECT_EQ(expected.float_save.control_word, |
179 observed->float_save.control_word); | 236 observed->float_save.control_word); |
180 EXPECT_EQ(expected.float_save.status_word, observed->float_save.status_word); | 237 EXPECT_EQ(expected.float_save.status_word, observed->float_save.status_word); |
181 EXPECT_EQ(expected.float_save.tag_word, observed->float_save.tag_word); | 238 EXPECT_EQ(expected.float_save.tag_word, observed->float_save.tag_word); |
182 EXPECT_EQ(expected.float_save.error_offset, | 239 EXPECT_EQ(expected.float_save.error_offset, |
183 observed->float_save.error_offset); | 240 observed->float_save.error_offset); |
184 EXPECT_EQ(expected.float_save.error_selector, | 241 EXPECT_EQ(expected.float_save.error_selector, |
185 observed->float_save.error_selector); | 242 observed->float_save.error_selector); |
186 EXPECT_EQ(expected.float_save.data_offset, observed->float_save.data_offset); | 243 EXPECT_EQ(expected.float_save.data_offset, observed->float_save.data_offset); |
187 EXPECT_EQ(expected.float_save.data_selector, | 244 EXPECT_EQ(expected.float_save.data_selector, |
188 observed->float_save.data_selector); | 245 observed->float_save.data_selector); |
189 for (size_t index = 0; | 246 for (size_t index = 0; |
190 index < arraysize(expected.float_save.register_area); | 247 index < arraysize(expected.float_save.register_area); |
191 ++index) { | 248 ++index) { |
192 EXPECT_EQ(expected.float_save.register_area[index], | 249 EXPECT_EQ(expected.float_save.register_area[index], |
193 observed->float_save.register_area[index]); | 250 observed->float_save.register_area[index]) << "index " << index; |
194 } | 251 } |
195 EXPECT_EQ(expected.float_save.spare_0, observed->float_save.spare_0); | 252 if (snapshot) { |
253 EXPECT_EQ(0u, observed->float_save.spare_0); | |
254 } else { | |
255 EXPECT_EQ(expected.float_save.spare_0, observed->float_save.spare_0); | |
256 } | |
257 | |
196 EXPECT_EQ(expected.gs, observed->gs); | 258 EXPECT_EQ(expected.gs, observed->gs); |
197 EXPECT_EQ(expected.fs, observed->fs); | 259 EXPECT_EQ(expected.fs, observed->fs); |
198 EXPECT_EQ(expected.es, observed->es); | 260 EXPECT_EQ(expected.es, observed->es); |
199 EXPECT_EQ(expected.ds, observed->ds); | 261 EXPECT_EQ(expected.ds, observed->ds); |
200 EXPECT_EQ(expected.edi, observed->edi); | 262 EXPECT_EQ(expected.edi, observed->edi); |
201 EXPECT_EQ(expected.esi, observed->esi); | 263 EXPECT_EQ(expected.esi, observed->esi); |
202 EXPECT_EQ(expected.ebx, observed->ebx); | 264 EXPECT_EQ(expected.ebx, observed->ebx); |
203 EXPECT_EQ(expected.edx, observed->edx); | 265 EXPECT_EQ(expected.edx, observed->edx); |
204 EXPECT_EQ(expected.ecx, observed->ecx); | 266 EXPECT_EQ(expected.ecx, observed->ecx); |
205 EXPECT_EQ(expected.eax, observed->eax); | 267 EXPECT_EQ(expected.eax, observed->eax); |
206 EXPECT_EQ(expected.ebp, observed->ebp); | 268 EXPECT_EQ(expected.ebp, observed->ebp); |
207 EXPECT_EQ(expected.eip, observed->eip); | 269 EXPECT_EQ(expected.eip, observed->eip); |
208 EXPECT_EQ(expected.cs, observed->cs); | 270 EXPECT_EQ(expected.cs, observed->cs); |
209 EXPECT_EQ(expected.eflags, observed->eflags); | 271 EXPECT_EQ(expected.eflags, observed->eflags); |
210 EXPECT_EQ(expected.esp, observed->esp); | 272 EXPECT_EQ(expected.esp, observed->esp); |
211 EXPECT_EQ(expected.ss, observed->ss); | 273 EXPECT_EQ(expected.ss, observed->ss); |
212 for (size_t index = 0; | 274 |
213 index < arraysize(expected.extended_registers); | 275 ExpectMinidumpContextFxsave(&expected.fxsave, &observed->fxsave); |
214 ++index) { | |
215 EXPECT_EQ(expected.extended_registers[index], | |
216 observed->extended_registers[index]); | |
217 } | |
218 } | 276 } |
219 | 277 |
220 void ExpectMinidumpContextAMD64(uint32_t expect_seed, | 278 void ExpectMinidumpContextAMD64( |
221 const MinidumpContextAMD64* observed) { | 279 uint32_t expect_seed, const MinidumpContextAMD64* observed, bool snapshot) { |
222 MinidumpContextAMD64 expected; | 280 MinidumpContextAMD64 expected; |
223 InitializeMinidumpContextAMD64(&expected, expect_seed); | 281 InitializeMinidumpContextAMD64(&expected, expect_seed); |
224 | 282 |
225 EXPECT_EQ(expected.context_flags, observed->context_flags); | 283 EXPECT_EQ(expected.context_flags, observed->context_flags); |
226 EXPECT_EQ(expected.p1_home, observed->p1_home); | 284 |
227 EXPECT_EQ(expected.p2_home, observed->p2_home); | 285 if (snapshot) { |
228 EXPECT_EQ(expected.p3_home, observed->p3_home); | 286 EXPECT_EQ(0u, observed->p1_home); |
229 EXPECT_EQ(expected.p4_home, observed->p4_home); | 287 EXPECT_EQ(0u, observed->p2_home); |
230 EXPECT_EQ(expected.p5_home, observed->p5_home); | 288 EXPECT_EQ(0u, observed->p3_home); |
231 EXPECT_EQ(expected.p6_home, observed->p6_home); | 289 EXPECT_EQ(0u, observed->p4_home); |
290 EXPECT_EQ(0u, observed->p5_home); | |
291 EXPECT_EQ(0u, observed->p6_home); | |
292 } else { | |
293 EXPECT_EQ(expected.p1_home, observed->p1_home); | |
294 EXPECT_EQ(expected.p2_home, observed->p2_home); | |
295 EXPECT_EQ(expected.p3_home, observed->p3_home); | |
296 EXPECT_EQ(expected.p4_home, observed->p4_home); | |
297 EXPECT_EQ(expected.p5_home, observed->p5_home); | |
298 EXPECT_EQ(expected.p6_home, observed->p6_home); | |
299 } | |
300 | |
232 EXPECT_EQ(expected.mx_csr, observed->mx_csr); | 301 EXPECT_EQ(expected.mx_csr, observed->mx_csr); |
302 | |
233 EXPECT_EQ(expected.cs, observed->cs); | 303 EXPECT_EQ(expected.cs, observed->cs); |
234 EXPECT_EQ(expected.ds, observed->ds); | 304 if (snapshot) { |
235 EXPECT_EQ(expected.es, observed->es); | 305 EXPECT_EQ(0u, observed->ds); |
306 EXPECT_EQ(0u, observed->es); | |
307 } else { | |
308 EXPECT_EQ(expected.ds, observed->ds); | |
309 EXPECT_EQ(expected.es, observed->es); | |
310 } | |
236 EXPECT_EQ(expected.fs, observed->fs); | 311 EXPECT_EQ(expected.fs, observed->fs); |
237 EXPECT_EQ(expected.gs, observed->gs); | 312 EXPECT_EQ(expected.gs, observed->gs); |
238 EXPECT_EQ(expected.ss, observed->ss); | 313 if (snapshot) { |
314 EXPECT_EQ(0u, observed->ss); | |
315 } else { | |
316 EXPECT_EQ(expected.ss, observed->ss); | |
317 } | |
318 | |
239 EXPECT_EQ(expected.eflags, observed->eflags); | 319 EXPECT_EQ(expected.eflags, observed->eflags); |
320 | |
240 EXPECT_EQ(expected.dr0, observed->dr0); | 321 EXPECT_EQ(expected.dr0, observed->dr0); |
241 EXPECT_EQ(expected.dr1, observed->dr1); | 322 EXPECT_EQ(expected.dr1, observed->dr1); |
242 EXPECT_EQ(expected.dr2, observed->dr2); | 323 EXPECT_EQ(expected.dr2, observed->dr2); |
243 EXPECT_EQ(expected.dr3, observed->dr3); | 324 EXPECT_EQ(expected.dr3, observed->dr3); |
244 EXPECT_EQ(expected.dr6, observed->dr6); | 325 EXPECT_EQ(expected.dr6, observed->dr6); |
245 EXPECT_EQ(expected.dr7, observed->dr7); | 326 EXPECT_EQ(expected.dr7, observed->dr7); |
327 | |
246 EXPECT_EQ(expected.rax, observed->rax); | 328 EXPECT_EQ(expected.rax, observed->rax); |
247 EXPECT_EQ(expected.rcx, observed->rcx); | 329 EXPECT_EQ(expected.rcx, observed->rcx); |
248 EXPECT_EQ(expected.rdx, observed->rdx); | 330 EXPECT_EQ(expected.rdx, observed->rdx); |
249 EXPECT_EQ(expected.rbx, observed->rbx); | 331 EXPECT_EQ(expected.rbx, observed->rbx); |
250 EXPECT_EQ(expected.rsp, observed->rsp); | 332 EXPECT_EQ(expected.rsp, observed->rsp); |
251 EXPECT_EQ(expected.rbp, observed->rbp); | 333 EXPECT_EQ(expected.rbp, observed->rbp); |
252 EXPECT_EQ(expected.rsi, observed->rsi); | 334 EXPECT_EQ(expected.rsi, observed->rsi); |
253 EXPECT_EQ(expected.rdi, observed->rdi); | 335 EXPECT_EQ(expected.rdi, observed->rdi); |
254 EXPECT_EQ(expected.r8, observed->r8); | 336 EXPECT_EQ(expected.r8, observed->r8); |
255 EXPECT_EQ(expected.r9, observed->r9); | 337 EXPECT_EQ(expected.r9, observed->r9); |
256 EXPECT_EQ(expected.r10, observed->r10); | 338 EXPECT_EQ(expected.r10, observed->r10); |
257 EXPECT_EQ(expected.r11, observed->r11); | 339 EXPECT_EQ(expected.r11, observed->r11); |
258 EXPECT_EQ(expected.r12, observed->r12); | 340 EXPECT_EQ(expected.r12, observed->r12); |
259 EXPECT_EQ(expected.r13, observed->r13); | 341 EXPECT_EQ(expected.r13, observed->r13); |
260 EXPECT_EQ(expected.r14, observed->r14); | 342 EXPECT_EQ(expected.r14, observed->r14); |
261 EXPECT_EQ(expected.r15, observed->r15); | 343 EXPECT_EQ(expected.r15, observed->r15); |
262 EXPECT_EQ(expected.rip, observed->rip); | 344 EXPECT_EQ(expected.rip, observed->rip); |
263 EXPECT_EQ(expected.float_save.control_word, | 345 |
264 observed->float_save.control_word); | 346 ExpectMinidumpContextFxsave(&expected.fxsave, &observed->fxsave); |
265 EXPECT_EQ(expected.float_save.status_word, observed->float_save.status_word); | 347 |
266 EXPECT_EQ(expected.float_save.tag_word, observed->float_save.tag_word); | 348 for (size_t index = 0; index < arraysize(expected.vector_register); ++index) { |
267 EXPECT_EQ(expected.float_save.reserved_1, observed->float_save.reserved_1); | 349 if (snapshot) { |
268 EXPECT_EQ(expected.float_save.error_opcode, | 350 EXPECT_EQ(0u, observed->vector_register[index].lo) << "index " << index; |
269 observed->float_save.error_opcode); | 351 EXPECT_EQ(0u, observed->vector_register[index].hi) << "index " << index; |
270 EXPECT_EQ(expected.float_save.error_offset, | 352 } else { |
271 observed->float_save.error_offset); | 353 EXPECT_EQ(expected.vector_register[index].lo, |
272 EXPECT_EQ(expected.float_save.error_selector, | 354 observed->vector_register[index].lo) << "index " << index; |
273 observed->float_save.error_selector); | 355 EXPECT_EQ(expected.vector_register[index].hi, |
274 EXPECT_EQ(expected.float_save.reserved_2, observed->float_save.reserved_2); | 356 observed->vector_register[index].hi) << "index " << index; |
275 EXPECT_EQ(expected.float_save.data_offset, observed->float_save.data_offset); | 357 } |
276 EXPECT_EQ(expected.float_save.data_selector, | |
277 observed->float_save.data_selector); | |
278 EXPECT_EQ(expected.float_save.reserved_3, observed->float_save.reserved_3); | |
279 EXPECT_EQ(expected.float_save.mx_csr, observed->float_save.mx_csr); | |
280 EXPECT_EQ(expected.float_save.mx_csr_mask, observed->float_save.mx_csr_mask); | |
281 for (size_t index = 0; | |
282 index < arraysize(expected.float_save.float_registers); | |
283 ++index) { | |
284 EXPECT_EQ(expected.float_save.float_registers[index].lo, | |
285 observed->float_save.float_registers[index].lo); | |
286 EXPECT_EQ(expected.float_save.float_registers[index].hi, | |
287 observed->float_save.float_registers[index].hi); | |
288 } | 358 } |
289 for (size_t index = 0; | 359 |
290 index < arraysize(expected.float_save.xmm_registers); | 360 if (snapshot) { |
291 ++index) { | 361 EXPECT_EQ(0u, observed->vector_control); |
292 EXPECT_EQ(expected.float_save.xmm_registers[index].lo, | 362 EXPECT_EQ(0u, observed->debug_control); |
293 observed->float_save.xmm_registers[index].lo); | 363 EXPECT_EQ(0u, observed->last_branch_to_rip); |
294 EXPECT_EQ(expected.float_save.xmm_registers[index].hi, | 364 EXPECT_EQ(0u, observed->last_branch_from_rip); |
295 observed->float_save.xmm_registers[index].hi); | 365 EXPECT_EQ(0u, observed->last_exception_to_rip); |
366 EXPECT_EQ(0u, observed->last_exception_from_rip); | |
367 } else { | |
368 EXPECT_EQ(expected.vector_control, observed->vector_control); | |
369 EXPECT_EQ(expected.debug_control, observed->debug_control); | |
370 EXPECT_EQ(expected.last_branch_to_rip, observed->last_branch_to_rip); | |
371 EXPECT_EQ(expected.last_branch_from_rip, observed->last_branch_from_rip); | |
372 EXPECT_EQ(expected.last_exception_to_rip, observed->last_exception_to_rip); | |
373 EXPECT_EQ(expected.last_exception_from_rip, | |
374 observed->last_exception_from_rip); | |
296 } | 375 } |
297 for (size_t index = 0; | |
298 index < arraysize(expected.float_save.reserved_4); | |
299 ++index) { | |
300 EXPECT_EQ(expected.float_save.reserved_4[index], | |
301 observed->float_save.reserved_4[index]); | |
302 } | |
303 for (size_t index = 0; index < arraysize(expected.vector_register); ++index) { | |
304 EXPECT_EQ(expected.vector_register[index].lo, | |
305 observed->vector_register[index].lo); | |
306 EXPECT_EQ(expected.vector_register[index].hi, | |
307 observed->vector_register[index].hi); | |
308 } | |
309 EXPECT_EQ(expected.vector_control, observed->vector_control); | |
310 EXPECT_EQ(expected.debug_control, observed->debug_control); | |
311 EXPECT_EQ(expected.last_branch_to_rip, observed->last_branch_to_rip); | |
312 EXPECT_EQ(expected.last_branch_from_rip, observed->last_branch_from_rip); | |
313 EXPECT_EQ(expected.last_exception_to_rip, observed->last_exception_to_rip); | |
314 EXPECT_EQ(expected.last_exception_from_rip, | |
315 observed->last_exception_from_rip); | |
316 } | 376 } |
317 | 377 |
318 } // namespace test | 378 } // namespace test |
319 } // namespace crashpad | 379 } // namespace crashpad |
OLD | NEW |