]>
Commit | Line | Data |
---|---|---|
1 | // This file was generated by gen_asm_instrumentation.sh. Please, do not edit | |
2 | // manually. | |
3 | #ifdef __linux__ | |
4 | .section .text | |
5 | #if defined(__x86_64__) || defined(__i386__) | |
6 | .globl __asan_report_store1 | |
7 | .globl __asan_report_load1 | |
8 | .globl __asan_report_store2 | |
9 | .globl __asan_report_load2 | |
10 | .globl __asan_report_store4 | |
11 | .globl __asan_report_load4 | |
12 | .globl __asan_report_store8 | |
13 | .globl __asan_report_load8 | |
14 | .globl __asan_report_store16 | |
15 | .globl __asan_report_load16 | |
16 | #endif // defined(__x86_64__) || defined(__i386__) | |
17 | #if defined(__i386__) | |
18 | // Sanitize 1-byte store. Takes one 4-byte address as an argument on | |
19 | // stack, nothing is returned. | |
20 | .globl __sanitizer_sanitize_store1 | |
21 | .type __sanitizer_sanitize_store1, @function | |
22 | __sanitizer_sanitize_store1: | |
23 | pushl %ebp | |
24 | movl %esp, %ebp | |
25 | pushl %eax | |
26 | pushl %ecx | |
27 | pushl %edx | |
28 | pushfl | |
29 | movl 8(%ebp), %eax | |
30 | movl %eax, %ecx | |
31 | shrl $0x3, %ecx | |
32 | movb 0x20000000(%ecx), %cl | |
33 | testb %cl, %cl | |
34 | je .sanitize_store1_done | |
35 | movl %eax, %edx | |
36 | andl $0x7, %edx | |
37 | movsbl %cl, %ecx | |
38 | cmpl %ecx, %edx | |
39 | jl .sanitize_store1_done | |
40 | pushl %eax | |
41 | cld | |
42 | emms | |
43 | call __asan_report_store1@PLT | |
44 | .sanitize_store1_done: | |
45 | popfl | |
46 | popl %edx | |
47 | popl %ecx | |
48 | popl %eax | |
49 | leave | |
50 | ret | |
51 | // Sanitize 1-byte load. Takes one 4-byte address as an argument on | |
52 | // stack, nothing is returned. | |
53 | .globl __sanitizer_sanitize_load1 | |
54 | .type __sanitizer_sanitize_load1, @function | |
55 | __sanitizer_sanitize_load1: | |
56 | pushl %ebp | |
57 | movl %esp, %ebp | |
58 | pushl %eax | |
59 | pushl %ecx | |
60 | pushl %edx | |
61 | pushfl | |
62 | movl 8(%ebp), %eax | |
63 | movl %eax, %ecx | |
64 | shrl $0x3, %ecx | |
65 | movb 0x20000000(%ecx), %cl | |
66 | testb %cl, %cl | |
67 | je .sanitize_load1_done | |
68 | movl %eax, %edx | |
69 | andl $0x7, %edx | |
70 | movsbl %cl, %ecx | |
71 | cmpl %ecx, %edx | |
72 | jl .sanitize_load1_done | |
73 | pushl %eax | |
74 | cld | |
75 | emms | |
76 | call __asan_report_load1@PLT | |
77 | .sanitize_load1_done: | |
78 | popfl | |
79 | popl %edx | |
80 | popl %ecx | |
81 | popl %eax | |
82 | leave | |
83 | ret | |
84 | // Sanitize 2-byte store. Takes one 4-byte address as an argument on | |
85 | // stack, nothing is returned. | |
86 | .globl __sanitizer_sanitize_store2 | |
87 | .type __sanitizer_sanitize_store2, @function | |
88 | __sanitizer_sanitize_store2: | |
89 | pushl %ebp | |
90 | movl %esp, %ebp | |
91 | pushl %eax | |
92 | pushl %ecx | |
93 | pushl %edx | |
94 | pushfl | |
95 | movl 8(%ebp), %eax | |
96 | movl %eax, %ecx | |
97 | shrl $0x3, %ecx | |
98 | movb 0x20000000(%ecx), %cl | |
99 | testb %cl, %cl | |
100 | je .sanitize_store2_done | |
101 | movl %eax, %edx | |
102 | andl $0x7, %edx | |
103 | incl %edx | |
104 | movsbl %cl, %ecx | |
105 | cmpl %ecx, %edx | |
106 | jl .sanitize_store2_done | |
107 | pushl %eax | |
108 | cld | |
109 | emms | |
110 | call __asan_report_store2@PLT | |
111 | .sanitize_store2_done: | |
112 | popfl | |
113 | popl %edx | |
114 | popl %ecx | |
115 | popl %eax | |
116 | leave | |
117 | ret | |
118 | // Sanitize 2-byte load. Takes one 4-byte address as an argument on | |
119 | // stack, nothing is returned. | |
120 | .globl __sanitizer_sanitize_load2 | |
121 | .type __sanitizer_sanitize_load2, @function | |
122 | __sanitizer_sanitize_load2: | |
123 | pushl %ebp | |
124 | movl %esp, %ebp | |
125 | pushl %eax | |
126 | pushl %ecx | |
127 | pushl %edx | |
128 | pushfl | |
129 | movl 8(%ebp), %eax | |
130 | movl %eax, %ecx | |
131 | shrl $0x3, %ecx | |
132 | movb 0x20000000(%ecx), %cl | |
133 | testb %cl, %cl | |
134 | je .sanitize_load2_done | |
135 | movl %eax, %edx | |
136 | andl $0x7, %edx | |
137 | incl %edx | |
138 | movsbl %cl, %ecx | |
139 | cmpl %ecx, %edx | |
140 | jl .sanitize_load2_done | |
141 | pushl %eax | |
142 | cld | |
143 | emms | |
144 | call __asan_report_load2@PLT | |
145 | .sanitize_load2_done: | |
146 | popfl | |
147 | popl %edx | |
148 | popl %ecx | |
149 | popl %eax | |
150 | leave | |
151 | ret | |
152 | // Sanitize 4-byte store. Takes one 4-byte address as an argument on | |
153 | // stack, nothing is returned. | |
154 | .globl __sanitizer_sanitize_store4 | |
155 | .type __sanitizer_sanitize_store4, @function | |
156 | __sanitizer_sanitize_store4: | |
157 | pushl %ebp | |
158 | movl %esp, %ebp | |
159 | pushl %eax | |
160 | pushl %ecx | |
161 | pushl %edx | |
162 | pushfl | |
163 | movl 8(%ebp), %eax | |
164 | movl %eax, %ecx | |
165 | shrl $0x3, %ecx | |
166 | movb 0x20000000(%ecx), %cl | |
167 | testb %cl, %cl | |
168 | je .sanitize_store4_done | |
169 | movl %eax, %edx | |
170 | andl $0x7, %edx | |
171 | addl $0x3, %edx | |
172 | movsbl %cl, %ecx | |
173 | cmpl %ecx, %edx | |
174 | jl .sanitize_store4_done | |
175 | pushl %eax | |
176 | cld | |
177 | emms | |
178 | call __asan_report_store4@PLT | |
179 | .sanitize_store4_done: | |
180 | popfl | |
181 | popl %edx | |
182 | popl %ecx | |
183 | popl %eax | |
184 | leave | |
185 | ret | |
186 | // Sanitize 4-byte load. Takes one 4-byte address as an argument on | |
187 | // stack, nothing is returned. | |
188 | .globl __sanitizer_sanitize_load4 | |
189 | .type __sanitizer_sanitize_load4, @function | |
190 | __sanitizer_sanitize_load4: | |
191 | pushl %ebp | |
192 | movl %esp, %ebp | |
193 | pushl %eax | |
194 | pushl %ecx | |
195 | pushl %edx | |
196 | pushfl | |
197 | movl 8(%ebp), %eax | |
198 | movl %eax, %ecx | |
199 | shrl $0x3, %ecx | |
200 | movb 0x20000000(%ecx), %cl | |
201 | testb %cl, %cl | |
202 | je .sanitize_load4_done | |
203 | movl %eax, %edx | |
204 | andl $0x7, %edx | |
205 | addl $0x3, %edx | |
206 | movsbl %cl, %ecx | |
207 | cmpl %ecx, %edx | |
208 | jl .sanitize_load4_done | |
209 | pushl %eax | |
210 | cld | |
211 | emms | |
212 | call __asan_report_load4@PLT | |
213 | .sanitize_load4_done: | |
214 | popfl | |
215 | popl %edx | |
216 | popl %ecx | |
217 | popl %eax | |
218 | leave | |
219 | ret | |
220 | // Sanitize 8-byte store. Takes one 4-byte address as an argument on | |
221 | // stack, nothing is returned. | |
222 | .globl __sanitizer_sanitize_store8 | |
223 | .type __sanitizer_sanitize_store8, @function | |
224 | __sanitizer_sanitize_store8: | |
225 | pushl %ebp | |
226 | movl %esp, %ebp | |
227 | pushl %eax | |
228 | pushl %ecx | |
229 | pushfl | |
230 | movl 8(%ebp), %eax | |
231 | movl %eax, %ecx | |
232 | shrl $0x3, %ecx | |
233 | cmpb $0x0, 0x20000000(%ecx) | |
234 | je .sanitize_store8_done | |
235 | pushl %eax | |
236 | cld | |
237 | emms | |
238 | call __asan_report_store8@PLT | |
239 | .sanitize_store8_done: | |
240 | popfl | |
241 | popl %ecx | |
242 | popl %eax | |
243 | leave | |
244 | ret | |
245 | // Sanitize 8-byte load. Takes one 4-byte address as an argument on | |
246 | // stack, nothing is returned. | |
247 | .globl __sanitizer_sanitize_load8 | |
248 | .type __sanitizer_sanitize_load8, @function | |
249 | __sanitizer_sanitize_load8: | |
250 | pushl %ebp | |
251 | movl %esp, %ebp | |
252 | pushl %eax | |
253 | pushl %ecx | |
254 | pushfl | |
255 | movl 8(%ebp), %eax | |
256 | movl %eax, %ecx | |
257 | shrl $0x3, %ecx | |
258 | cmpb $0x0, 0x20000000(%ecx) | |
259 | je .sanitize_load8_done | |
260 | pushl %eax | |
261 | cld | |
262 | emms | |
263 | call __asan_report_load8@PLT | |
264 | .sanitize_load8_done: | |
265 | popfl | |
266 | popl %ecx | |
267 | popl %eax | |
268 | leave | |
269 | ret | |
270 | // Sanitize 16-byte store. Takes one 4-byte address as an argument on | |
271 | // stack, nothing is returned. | |
272 | .globl __sanitizer_sanitize_store16 | |
273 | .type __sanitizer_sanitize_store16, @function | |
274 | __sanitizer_sanitize_store16: | |
275 | pushl %ebp | |
276 | movl %esp, %ebp | |
277 | pushl %eax | |
278 | pushl %ecx | |
279 | pushfl | |
280 | movl 8(%ebp), %eax | |
281 | movl %eax, %ecx | |
282 | shrl $0x3, %ecx | |
283 | cmpw $0x0, 0x20000000(%ecx) | |
284 | je .sanitize_store16_done | |
285 | pushl %eax | |
286 | cld | |
287 | emms | |
288 | call __asan_report_store16@PLT | |
289 | .sanitize_store16_done: | |
290 | popfl | |
291 | popl %ecx | |
292 | popl %eax | |
293 | leave | |
294 | ret | |
295 | // Sanitize 16-byte load. Takes one 4-byte address as an argument on | |
296 | // stack, nothing is returned. | |
297 | .globl __sanitizer_sanitize_load16 | |
298 | .type __sanitizer_sanitize_load16, @function | |
299 | __sanitizer_sanitize_load16: | |
300 | pushl %ebp | |
301 | movl %esp, %ebp | |
302 | pushl %eax | |
303 | pushl %ecx | |
304 | pushfl | |
305 | movl 8(%ebp), %eax | |
306 | movl %eax, %ecx | |
307 | shrl $0x3, %ecx | |
308 | cmpw $0x0, 0x20000000(%ecx) | |
309 | je .sanitize_load16_done | |
310 | pushl %eax | |
311 | cld | |
312 | emms | |
313 | call __asan_report_load16@PLT | |
314 | .sanitize_load16_done: | |
315 | popfl | |
316 | popl %ecx | |
317 | popl %eax | |
318 | leave | |
319 | ret | |
320 | #endif // defined(__i386__) | |
321 | #if defined(__x86_64__) | |
322 | // Sanitize 1-byte store. Takes one 8-byte address as an argument in %rdi, | |
323 | // nothing is returned. | |
324 | .globl __sanitizer_sanitize_store1 | |
325 | .type __sanitizer_sanitize_store1, @function | |
326 | __sanitizer_sanitize_store1: | |
327 | subq $128, %rsp | |
328 | pushq %rax | |
329 | pushq %rcx | |
330 | pushfq | |
331 | movq %rdi, %rax | |
332 | shrq $0x3, %rax | |
333 | movb 0x7fff8000(%rax), %al | |
334 | test %al, %al | |
335 | je .sanitize_store1_done | |
336 | movl %edi, %ecx | |
337 | andl $0x7, %ecx | |
338 | movsbl %al, %eax | |
339 | cmpl %eax, %ecx | |
340 | jl .sanitize_store1_done | |
341 | subq $8, %rsp | |
342 | andq $-16, %rsp | |
343 | cld | |
344 | emms | |
345 | call __asan_report_store1@PLT | |
346 | .sanitize_store1_done: | |
347 | popfq | |
348 | popq %rcx | |
349 | popq %rax | |
350 | addq $128, %rsp | |
351 | ret | |
352 | // Sanitize 1-byte load. Takes one 8-byte address as an argument in %rdi, | |
353 | // nothing is returned. | |
354 | .globl __sanitizer_sanitize_load1 | |
355 | .type __sanitizer_sanitize_load1, @function | |
356 | __sanitizer_sanitize_load1: | |
357 | subq $128, %rsp | |
358 | pushq %rax | |
359 | pushq %rcx | |
360 | pushfq | |
361 | movq %rdi, %rax | |
362 | shrq $0x3, %rax | |
363 | movb 0x7fff8000(%rax), %al | |
364 | test %al, %al | |
365 | je .sanitize_load1_done | |
366 | movl %edi, %ecx | |
367 | andl $0x7, %ecx | |
368 | movsbl %al, %eax | |
369 | cmpl %eax, %ecx | |
370 | jl .sanitize_load1_done | |
371 | subq $8, %rsp | |
372 | andq $-16, %rsp | |
373 | cld | |
374 | emms | |
375 | call __asan_report_load1@PLT | |
376 | .sanitize_load1_done: | |
377 | popfq | |
378 | popq %rcx | |
379 | popq %rax | |
380 | addq $128, %rsp | |
381 | ret | |
382 | // Sanitize 2-byte store. Takes one 8-byte address as an argument in %rdi, | |
383 | // nothing is returned. | |
384 | .globl __sanitizer_sanitize_store2 | |
385 | .type __sanitizer_sanitize_store2, @function | |
386 | __sanitizer_sanitize_store2: | |
387 | subq $128, %rsp | |
388 | pushq %rax | |
389 | pushq %rcx | |
390 | pushfq | |
391 | movq %rdi, %rax | |
392 | shrq $0x3, %rax | |
393 | movb 0x7fff8000(%rax), %al | |
394 | test %al, %al | |
395 | je .sanitize_store2_done | |
396 | movl %edi, %ecx | |
397 | andl $0x7, %ecx | |
398 | incl %ecx | |
399 | movsbl %al, %eax | |
400 | cmpl %eax, %ecx | |
401 | jl .sanitize_store2_done | |
402 | subq $8, %rsp | |
403 | andq $-16, %rsp | |
404 | cld | |
405 | emms | |
406 | call __asan_report_store2@PLT | |
407 | .sanitize_store2_done: | |
408 | popfq | |
409 | popq %rcx | |
410 | popq %rax | |
411 | addq $128, %rsp | |
412 | ret | |
413 | // Sanitize 2-byte load. Takes one 8-byte address as an argument in %rdi, | |
414 | // nothing is returned. | |
415 | .globl __sanitizer_sanitize_load2 | |
416 | .type __sanitizer_sanitize_load2, @function | |
417 | __sanitizer_sanitize_load2: | |
418 | subq $128, %rsp | |
419 | pushq %rax | |
420 | pushq %rcx | |
421 | pushfq | |
422 | movq %rdi, %rax | |
423 | shrq $0x3, %rax | |
424 | movb 0x7fff8000(%rax), %al | |
425 | test %al, %al | |
426 | je .sanitize_load2_done | |
427 | movl %edi, %ecx | |
428 | andl $0x7, %ecx | |
429 | incl %ecx | |
430 | movsbl %al, %eax | |
431 | cmpl %eax, %ecx | |
432 | jl .sanitize_load2_done | |
433 | subq $8, %rsp | |
434 | andq $-16, %rsp | |
435 | cld | |
436 | emms | |
437 | call __asan_report_load2@PLT | |
438 | .sanitize_load2_done: | |
439 | popfq | |
440 | popq %rcx | |
441 | popq %rax | |
442 | addq $128, %rsp | |
443 | ret | |
444 | // Sanitize 4-byte store. Takes one 8-byte address as an argument in %rdi, | |
445 | // nothing is returned. | |
446 | .globl __sanitizer_sanitize_store4 | |
447 | .type __sanitizer_sanitize_store4, @function | |
448 | __sanitizer_sanitize_store4: | |
449 | subq $128, %rsp | |
450 | pushq %rax | |
451 | pushq %rcx | |
452 | pushfq | |
453 | movq %rdi, %rax | |
454 | shrq $0x3, %rax | |
455 | movb 0x7fff8000(%rax), %al | |
456 | test %al, %al | |
457 | je .sanitize_store4_done | |
458 | movl %edi, %ecx | |
459 | andl $0x7, %ecx | |
460 | addl $0x3, %ecx | |
461 | movsbl %al, %eax | |
462 | cmpl %eax, %ecx | |
463 | jl .sanitize_store4_done | |
464 | subq $8, %rsp | |
465 | andq $-16, %rsp | |
466 | cld | |
467 | emms | |
468 | call __asan_report_store4@PLT | |
469 | .sanitize_store4_done: | |
470 | popfq | |
471 | popq %rcx | |
472 | popq %rax | |
473 | addq $128, %rsp | |
474 | ret | |
475 | // Sanitize 4-byte load. Takes one 8-byte address as an argument in %rdi, | |
476 | // nothing is returned. | |
477 | .globl __sanitizer_sanitize_load4 | |
478 | .type __sanitizer_sanitize_load4, @function | |
479 | __sanitizer_sanitize_load4: | |
480 | subq $128, %rsp | |
481 | pushq %rax | |
482 | pushq %rcx | |
483 | pushfq | |
484 | movq %rdi, %rax | |
485 | shrq $0x3, %rax | |
486 | movb 0x7fff8000(%rax), %al | |
487 | test %al, %al | |
488 | je .sanitize_load4_done | |
489 | movl %edi, %ecx | |
490 | andl $0x7, %ecx | |
491 | addl $0x3, %ecx | |
492 | movsbl %al, %eax | |
493 | cmpl %eax, %ecx | |
494 | jl .sanitize_load4_done | |
495 | subq $8, %rsp | |
496 | andq $-16, %rsp | |
497 | cld | |
498 | emms | |
499 | call __asan_report_load4@PLT | |
500 | .sanitize_load4_done: | |
501 | popfq | |
502 | popq %rcx | |
503 | popq %rax | |
504 | addq $128, %rsp | |
505 | ret | |
506 | // Sanitize 8-byte store. Takes one 8-byte address as an argument in %rdi, | |
507 | // nothing is returned. | |
508 | .globl __sanitizer_sanitize_store8 | |
509 | .type __sanitizer_sanitize_store8, @function | |
510 | __sanitizer_sanitize_store8: | |
511 | subq $128, %rsp | |
512 | pushq %rax | |
513 | pushfq | |
514 | movq %rdi, %rax | |
515 | shrq $0x3, %rax | |
516 | cmpb $0x0, 0x7fff8000(%rax) | |
517 | je .sanitize_store8_done | |
518 | subq $8, %rsp | |
519 | andq $-16, %rsp | |
520 | cld | |
521 | emms | |
522 | call __asan_report_store8@PLT | |
523 | .sanitize_store8_done: | |
524 | popfq | |
525 | popq %rax | |
526 | addq $128, %rsp | |
527 | ret | |
528 | // Sanitize 8-byte load. Takes one 8-byte address as an argument in %rdi, | |
529 | // nothing is returned. | |
530 | .globl __sanitizer_sanitize_load8 | |
531 | .type __sanitizer_sanitize_load8, @function | |
532 | __sanitizer_sanitize_load8: | |
533 | subq $128, %rsp | |
534 | pushq %rax | |
535 | pushfq | |
536 | movq %rdi, %rax | |
537 | shrq $0x3, %rax | |
538 | cmpb $0x0, 0x7fff8000(%rax) | |
539 | je .sanitize_load8_done | |
540 | subq $8, %rsp | |
541 | andq $-16, %rsp | |
542 | cld | |
543 | emms | |
544 | call __asan_report_load8@PLT | |
545 | .sanitize_load8_done: | |
546 | popfq | |
547 | popq %rax | |
548 | addq $128, %rsp | |
549 | ret | |
550 | // Sanitize 16-byte store. Takes one 8-byte address as an argument in %rdi, | |
551 | // nothing is returned. | |
552 | .globl __sanitizer_sanitize_store16 | |
553 | .type __sanitizer_sanitize_store16, @function | |
554 | __sanitizer_sanitize_store16: | |
555 | subq $128, %rsp | |
556 | pushq %rax | |
557 | pushfq | |
558 | movq %rdi, %rax | |
559 | shrq $0x3, %rax | |
560 | cmpw $0x0, 0x7fff8000(%rax) | |
561 | je .sanitize_store16_done | |
562 | subq $8, %rsp | |
563 | andq $-16, %rsp | |
564 | cld | |
565 | emms | |
566 | call __asan_report_store16@PLT | |
567 | .sanitize_store16_done: | |
568 | popfq | |
569 | popq %rax | |
570 | addq $128, %rsp | |
571 | ret | |
572 | // Sanitize 16-byte load. Takes one 8-byte address as an argument in %rdi, | |
573 | // nothing is returned. | |
574 | .globl __sanitizer_sanitize_load16 | |
575 | .type __sanitizer_sanitize_load16, @function | |
576 | __sanitizer_sanitize_load16: | |
577 | subq $128, %rsp | |
578 | pushq %rax | |
579 | pushfq | |
580 | movq %rdi, %rax | |
581 | shrq $0x3, %rax | |
582 | cmpw $0x0, 0x7fff8000(%rax) | |
583 | je .sanitize_load16_done | |
584 | subq $8, %rsp | |
585 | andq $-16, %rsp | |
586 | cld | |
587 | emms | |
588 | call __asan_report_load16@PLT | |
589 | .sanitize_load16_done: | |
590 | popfq | |
591 | popq %rax | |
592 | addq $128, %rsp | |
593 | ret | |
594 | #endif // defined(__x86_64__) | |
595 | /* We do not need executable stack. */ | |
596 | #if defined(__arm__) | |
597 | .section .note.GNU-stack,"",%progbits | |
598 | #else | |
599 | .section .note.GNU-stack,"",@progbits | |
600 | #endif // defined(__arm__) | |
601 | #endif // __linux__ |