[rustc.git] / src / compiler-rt / lib / asan / asan_asm_instrumentation.S

// This file was generated by gen_asm_instrumentation.sh. Please, do not edit
// manually.
#ifdef __linux__
.section .text
#if defined(__x86_64__) || defined(__i386__)
.globl __asan_report_store1
.globl __asan_report_load1
.globl __asan_report_store2
.globl __asan_report_load2
.globl __asan_report_store4
.globl __asan_report_load4
.globl __asan_report_store8
.globl __asan_report_load8
.globl __asan_report_store16
.globl __asan_report_load16
#endif //  defined(__x86_64__) || defined(__i386__)
#if defined(__i386__)
// Sanitize 1-byte store. Takes one 4-byte address as an argument on
// stack, nothing is returned.
.globl __sanitizer_sanitize_store1
.type __sanitizer_sanitize_store1, @function
__sanitizer_sanitize_store1:
  pushl %ebp
  movl %esp, %ebp
  pushl %eax
  pushl %ecx
  pushl %edx
  pushfl
  movl 8(%ebp), %eax
  movl %eax, %ecx
  shrl $0x3, %ecx
  movb 0x20000000(%ecx), %cl
  testb %cl, %cl
  je .sanitize_store1_done
  movl %eax, %edx
  andl $0x7, %edx
  movsbl %cl, %ecx
  cmpl %ecx, %edx
  jl .sanitize_store1_done
  pushl %eax
  cld
  emms
  call __asan_report_store1@PLT
.sanitize_store1_done:
  popfl
  popl %edx
  popl %ecx
  popl %eax
  leave
  ret
// Sanitize 1-byte load. Takes one 4-byte address as an argument on
// stack, nothing is returned.
.globl __sanitizer_sanitize_load1
.type __sanitizer_sanitize_load1, @function
__sanitizer_sanitize_load1:
  pushl %ebp
  movl %esp, %ebp
  pushl %eax
  pushl %ecx
  pushl %edx
  pushfl
  movl 8(%ebp), %eax
  movl %eax, %ecx
  shrl $0x3, %ecx
  movb 0x20000000(%ecx), %cl
  testb %cl, %cl
  je .sanitize_load1_done
  movl %eax, %edx
  andl $0x7, %edx
  movsbl %cl, %ecx
  cmpl %ecx, %edx
  jl .sanitize_load1_done
  pushl %eax
  cld
  emms
  call __asan_report_load1@PLT
.sanitize_load1_done:
  popfl
  popl %edx
  popl %ecx
  popl %eax
  leave
  ret
// Sanitize 2-byte store. Takes one 4-byte address as an argument on
// stack, nothing is returned.
.globl __sanitizer_sanitize_store2
.type __sanitizer_sanitize_store2, @function
__sanitizer_sanitize_store2:
  pushl %ebp
  movl %esp, %ebp
  pushl %eax
  pushl %ecx
  pushl %edx
  pushfl
  movl 8(%ebp), %eax
  movl %eax, %ecx
  shrl $0x3, %ecx
  movb 0x20000000(%ecx), %cl
  testb %cl, %cl
  je .sanitize_store2_done
  movl %eax, %edx
  andl $0x7, %edx
  incl %edx
  movsbl %cl, %ecx
  cmpl %ecx, %edx
  jl .sanitize_store2_done
  pushl %eax
  cld
  emms
  call __asan_report_store2@PLT
.sanitize_store2_done:
  popfl
  popl %edx
  popl %ecx
  popl %eax
  leave
  ret
// Sanitize 2-byte load. Takes one 4-byte address as an argument on
// stack, nothing is returned.
.globl __sanitizer_sanitize_load2
.type __sanitizer_sanitize_load2, @function
__sanitizer_sanitize_load2:
  pushl %ebp
  movl %esp, %ebp
  pushl %eax
  pushl %ecx
  pushl %edx
  pushfl
  movl 8(%ebp), %eax
  movl %eax, %ecx
  shrl $0x3, %ecx
  movb 0x20000000(%ecx), %cl
  testb %cl, %cl
  je .sanitize_load2_done
  movl %eax, %edx
  andl $0x7, %edx
  incl %edx
  movsbl %cl, %ecx
  cmpl %ecx, %edx
  jl .sanitize_load2_done
  pushl %eax
  cld
  emms
  call __asan_report_load2@PLT
.sanitize_load2_done:
  popfl
  popl %edx
  popl %ecx
  popl %eax
  leave
  ret
// Sanitize 4-byte store. Takes one 4-byte address as an argument on
// stack, nothing is returned.
.globl __sanitizer_sanitize_store4
.type __sanitizer_sanitize_store4, @function
__sanitizer_sanitize_store4:
  pushl %ebp
  movl %esp, %ebp
  pushl %eax
  pushl %ecx
  pushl %edx
  pushfl
  movl 8(%ebp), %eax
  movl %eax, %ecx
  shrl $0x3, %ecx
  movb 0x20000000(%ecx), %cl
  testb %cl, %cl
  je .sanitize_store4_done
  movl %eax, %edx
  andl $0x7, %edx
  addl $0x3, %edx
  movsbl %cl, %ecx
  cmpl %ecx, %edx
  jl .sanitize_store4_done
  pushl %eax
  cld
  emms
  call __asan_report_store4@PLT
.sanitize_store4_done:
  popfl
  popl %edx
  popl %ecx
  popl %eax
  leave
  ret
// Sanitize 4-byte load. Takes one 4-byte address as an argument on
// stack, nothing is returned.
.globl __sanitizer_sanitize_load4
.type __sanitizer_sanitize_load4, @function
__sanitizer_sanitize_load4:
  pushl %ebp
  movl %esp, %ebp
  pushl %eax
  pushl %ecx
  pushl %edx
  pushfl
  movl 8(%ebp), %eax
  movl %eax, %ecx
  shrl $0x3, %ecx
  movb 0x20000000(%ecx), %cl
  testb %cl, %cl
  je .sanitize_load4_done
  movl %eax, %edx
  andl $0x7, %edx
  addl $0x3, %edx
  movsbl %cl, %ecx
  cmpl %ecx, %edx
  jl .sanitize_load4_done
  pushl %eax
  cld
  emms
  call __asan_report_load4@PLT
.sanitize_load4_done:
  popfl
  popl %edx
  popl %ecx
  popl %eax
  leave
  ret
// Sanitize 8-byte store. Takes one 4-byte address as an argument on
// stack, nothing is returned.
.globl __sanitizer_sanitize_store8
.type __sanitizer_sanitize_store8, @function
__sanitizer_sanitize_store8:
  pushl %ebp
  movl %esp, %ebp
  pushl %eax
  pushl %ecx
  pushfl
  movl 8(%ebp), %eax
  movl %eax, %ecx
  shrl $0x3, %ecx
  cmpb $0x0, 0x20000000(%ecx)
  je .sanitize_store8_done
  pushl %eax
  cld
  emms
  call __asan_report_store8@PLT
.sanitize_store8_done:
  popfl
  popl %ecx
  popl %eax
  leave
  ret
// Sanitize 8-byte load. Takes one 4-byte address as an argument on
// stack, nothing is returned.
.globl __sanitizer_sanitize_load8
.type __sanitizer_sanitize_load8, @function
__sanitizer_sanitize_load8:
  pushl %ebp
  movl %esp, %ebp
  pushl %eax
  pushl %ecx
  pushfl
  movl 8(%ebp), %eax
  movl %eax, %ecx
  shrl $0x3, %ecx
  cmpb $0x0, 0x20000000(%ecx)
  je .sanitize_load8_done
  pushl %eax
  cld
  emms
  call __asan_report_load8@PLT
.sanitize_load8_done:
  popfl
  popl %ecx
  popl %eax
  leave
  ret
// Sanitize 16-byte store. Takes one 4-byte address as an argument on
// stack, nothing is returned.
.globl __sanitizer_sanitize_store16
.type __sanitizer_sanitize_store16, @function
__sanitizer_sanitize_store16:
  pushl %ebp
  movl %esp, %ebp
  pushl %eax
  pushl %ecx
  pushfl
  movl 8(%ebp), %eax
  movl %eax, %ecx
  shrl $0x3, %ecx
  cmpw $0x0, 0x20000000(%ecx)
  je .sanitize_store16_done
  pushl %eax
  cld
  emms
  call __asan_report_store16@PLT
.sanitize_store16_done:
  popfl
  popl %ecx
  popl %eax
  leave
  ret
// Sanitize 16-byte load. Takes one 4-byte address as an argument on
// stack, nothing is returned.
.globl __sanitizer_sanitize_load16
.type __sanitizer_sanitize_load16, @function
__sanitizer_sanitize_load16:
  pushl %ebp
  movl %esp, %ebp
  pushl %eax
  pushl %ecx
  pushfl
  movl 8(%ebp), %eax
  movl %eax, %ecx
  shrl $0x3, %ecx
  cmpw $0x0, 0x20000000(%ecx)
  je .sanitize_load16_done
  pushl %eax
  cld
  emms
  call __asan_report_load16@PLT
.sanitize_load16_done:
  popfl
  popl %ecx
  popl %eax
  leave
  ret
#endif // defined(__i386__)
#if defined(__x86_64__)
// Sanitize 1-byte store. Takes one 8-byte address as an argument in %rdi,
// nothing is returned.
.globl __sanitizer_sanitize_store1
.type __sanitizer_sanitize_store1, @function
__sanitizer_sanitize_store1:
  subq $128, %rsp
  pushq %rax
  pushq %rcx
  pushfq
  movq %rdi, %rax
  shrq $0x3, %rax
  movb 0x7fff8000(%rax), %al
  test %al, %al
  je .sanitize_store1_done
  movl %edi, %ecx
  andl $0x7, %ecx
  movsbl %al, %eax
  cmpl %eax, %ecx
  jl .sanitize_store1_done
  subq $8, %rsp
  andq $-16, %rsp
  cld
  emms
  call __asan_report_store1@PLT
.sanitize_store1_done:
  popfq
  popq %rcx
  popq %rax
  addq $128, %rsp
  ret
// Sanitize 1-byte load. Takes one 8-byte address as an argument in %rdi,
// nothing is returned.
.globl __sanitizer_sanitize_load1
.type __sanitizer_sanitize_load1, @function
__sanitizer_sanitize_load1:
  subq $128, %rsp
  pushq %rax
  pushq %rcx
  pushfq
  movq %rdi, %rax
  shrq $0x3, %rax
  movb 0x7fff8000(%rax), %al
  test %al, %al
  je .sanitize_load1_done
  movl %edi, %ecx
  andl $0x7, %ecx
  movsbl %al, %eax
  cmpl %eax, %ecx
  jl .sanitize_load1_done
  subq $8, %rsp
  andq $-16, %rsp
  cld
  emms
  call __asan_report_load1@PLT
.sanitize_load1_done:
  popfq
  popq %rcx
  popq %rax
  addq $128, %rsp
  ret
// Sanitize 2-byte store. Takes one 8-byte address as an argument in %rdi,
// nothing is returned.
.globl __sanitizer_sanitize_store2
.type __sanitizer_sanitize_store2, @function
__sanitizer_sanitize_store2:
  subq $128, %rsp
  pushq %rax
  pushq %rcx
  pushfq
  movq %rdi, %rax
  shrq $0x3, %rax
  movb 0x7fff8000(%rax), %al
  test %al, %al
  je .sanitize_store2_done
  movl %edi, %ecx
  andl $0x7, %ecx
  incl %ecx
  movsbl %al, %eax
  cmpl %eax, %ecx
  jl .sanitize_store2_done
  subq $8, %rsp
  andq $-16, %rsp
  cld
  emms
  call __asan_report_store2@PLT
.sanitize_store2_done:
  popfq
  popq %rcx
  popq %rax
  addq $128, %rsp
  ret
// Sanitize 2-byte load. Takes one 8-byte address as an argument in %rdi,
// nothing is returned.
.globl __sanitizer_sanitize_load2
.type __sanitizer_sanitize_load2, @function
__sanitizer_sanitize_load2:
  subq $128, %rsp
  pushq %rax
  pushq %rcx
  pushfq
  movq %rdi, %rax
  shrq $0x3, %rax
  movb 0x7fff8000(%rax), %al
  test %al, %al
  je .sanitize_load2_done
  movl %edi, %ecx
  andl $0x7, %ecx
  incl %ecx
  movsbl %al, %eax
  cmpl %eax, %ecx
  jl .sanitize_load2_done
  subq $8, %rsp
  andq $-16, %rsp
  cld
  emms
  call __asan_report_load2@PLT
.sanitize_load2_done:
  popfq
  popq %rcx
  popq %rax
  addq $128, %rsp
  ret
// Sanitize 4-byte store. Takes one 8-byte address as an argument in %rdi,
// nothing is returned.
.globl __sanitizer_sanitize_store4
.type __sanitizer_sanitize_store4, @function
__sanitizer_sanitize_store4:
  subq $128, %rsp
  pushq %rax
  pushq %rcx
  pushfq
  movq %rdi, %rax
  shrq $0x3, %rax
  movb 0x7fff8000(%rax), %al
  test %al, %al
  je .sanitize_store4_done
  movl %edi, %ecx
  andl $0x7, %ecx
  addl $0x3, %ecx
  movsbl %al, %eax
  cmpl %eax, %ecx
  jl .sanitize_store4_done
  subq $8, %rsp
  andq $-16, %rsp
  cld
  emms
  call __asan_report_store4@PLT
.sanitize_store4_done:
  popfq
  popq %rcx
  popq %rax
  addq $128, %rsp
  ret
// Sanitize 4-byte load. Takes one 8-byte address as an argument in %rdi,
// nothing is returned.
.globl __sanitizer_sanitize_load4
.type __sanitizer_sanitize_load4, @function
__sanitizer_sanitize_load4:
  subq $128, %rsp
  pushq %rax
  pushq %rcx
  pushfq
  movq %rdi, %rax
  shrq $0x3, %rax
  movb 0x7fff8000(%rax), %al
  test %al, %al
  je .sanitize_load4_done
  movl %edi, %ecx
  andl $0x7, %ecx
  addl $0x3, %ecx
  movsbl %al, %eax
  cmpl %eax, %ecx
  jl .sanitize_load4_done
  subq $8, %rsp
  andq $-16, %rsp
  cld
  emms
  call __asan_report_load4@PLT
.sanitize_load4_done:
  popfq
  popq %rcx
  popq %rax
  addq $128, %rsp
  ret
// Sanitize 8-byte store. Takes one 8-byte address as an argument in %rdi,
// nothing is returned.
.globl __sanitizer_sanitize_store8
.type __sanitizer_sanitize_store8, @function
__sanitizer_sanitize_store8:
  subq $128, %rsp
  pushq %rax
  pushfq
  movq %rdi, %rax
  shrq $0x3, %rax
  cmpb $0x0, 0x7fff8000(%rax)
  je .sanitize_store8_done
  subq $8, %rsp
  andq $-16, %rsp
  cld
  emms
  call __asan_report_store8@PLT
.sanitize_store8_done:
  popfq
  popq %rax
  addq $128, %rsp
  ret
// Sanitize 8-byte load. Takes one 8-byte address as an argument in %rdi,
// nothing is returned.
.globl __sanitizer_sanitize_load8
.type __sanitizer_sanitize_load8, @function
__sanitizer_sanitize_load8:
  subq $128, %rsp
  pushq %rax
  pushfq
  movq %rdi, %rax
  shrq $0x3, %rax
  cmpb $0x0, 0x7fff8000(%rax)
  je .sanitize_load8_done
  subq $8, %rsp
  andq $-16, %rsp
  cld
  emms
  call __asan_report_load8@PLT
.sanitize_load8_done:
  popfq
  popq %rax
  addq $128, %rsp
  ret
// Sanitize 16-byte store. Takes one 8-byte address as an argument in %rdi,
// nothing is returned.
.globl __sanitizer_sanitize_store16
.type __sanitizer_sanitize_store16, @function
__sanitizer_sanitize_store16:
  subq $128, %rsp
  pushq %rax
  pushfq
  movq %rdi, %rax
  shrq $0x3, %rax
  cmpw $0x0, 0x7fff8000(%rax)
  je .sanitize_store16_done
  subq $8, %rsp
  andq $-16, %rsp
  cld
  emms
  call __asan_report_store16@PLT
.sanitize_store16_done:
  popfq
  popq %rax
  addq $128, %rsp
  ret
// Sanitize 16-byte load. Takes one 8-byte address as an argument in %rdi,
// nothing is returned.
.globl __sanitizer_sanitize_load16
.type __sanitizer_sanitize_load16, @function
__sanitizer_sanitize_load16:
  subq $128, %rsp
  pushq %rax
  pushfq
  movq %rdi, %rax
  shrq $0x3, %rax
  cmpw $0x0, 0x7fff8000(%rax)
  je .sanitize_load16_done
  subq $8, %rsp
  andq $-16, %rsp
  cld
  emms
  call __asan_report_load16@PLT
.sanitize_load16_done:
  popfq
  popq %rax
  addq $128, %rsp
  ret
#endif // defined(__x86_64__)
/* We do not need executable stack. */
#if defined(__arm__)
  .section .note.GNU-stack,"",%progbits
#else
  .section .note.GNU-stack,"",@progbits
#endif // defined(__arm__)
#endif // __linux__
Commit	Line	Data
1a4d82fc JJ	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__