Syntax of asm instrumentation code is changed from AT&T to Intel.

[ygorshenin]

Summary

Syntax of asm instrumentation code is changed from AT&T to Intel.

[• ramosian.glider]

Please no. It's really weird to have Intel syntax in the code used mostly on Linux without a strong reason.

[eugenis]

AFAIU, this is an unfinished attempt to support windows build.
We'll try to directly emit everything this file does in MC instead.

[ygorshenin]

Closing the revision as it was decided to get rid of this .S file.

[ygribov]

We'll try to directly emit everything this file does in MC instead.

What about gcc though?

[eugenis]

These functions are used in asm instrumentation, which gcc can not do (well, it _could_ be done in gnu assembler).

Are you saying they can be used for the instrument-with-calls mode?

[ygribov]

These functions are used in asm instrumentation, which gcc can not do (well, it _could_ be done in gnu assembler).

My understanding was that they can also be used in inline asm which sounds like an important feature. Am I wrong?

Are you saying they can be used for the instrument-with-calls mode?

No, certainly not, that would be too slow.

[eugenis]

Yes, they are used for both inline asm and .s files.
Do you know of any plans to implement that in gcc-asan? As I understand, they don't have an integrated assembler and simply emit inline asm as text to .s.

[ygribov]

Do you know of any plans to implement that in gcc-asan?

You mean integrated asm? I don't think there are any plans for this in GCC. So I only care about ability to manually add instrumentation in inline asm and/or .S when necessary.

As I understand, they don't have an integrated assembler and simply emit inline asm as text to .s.

Yup.

lib/asan/asan_asm_instrumentation.S

 // This file was generated by gen_asm_instrumentation.sh. Please, do not edit
 // manually.
 #ifdef __linux__
+.intel_syntax noprefix;
 .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
+  push ebp
+  mov  ebp, esp
+  push eax
+  push ecx
+  push edx
+  pushfd
+  mov eax, dword ptr [ebp + 8]
+  mov ecx, eax
+  shr ecx, 0x3
+  mov cl, byte ptr [ecx + 0x20000000]
+  test cl, cl
   je .sanitize_store1_done
-  movl %eax, %edx
-  andl $0x7, %edx
-  movsbl %cl, %ecx
-  cmpl %ecx, %edx
+  mov edx, eax
+  and edx, 0x7
+  movsx ecx, cl
+  cmp edx, ecx
   jl .sanitize_store1_done
-  pushl %eax
+  push eax
   cld
   emms
   call __asan_report_store1@PLT
 .sanitize_store1_done:
-  popfl
-  popl %edx
-  popl %ecx
-  popl %eax
+  popfd
+  pop edx
+  pop ecx
+  pop 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
+  push ebp
+  mov  ebp, esp
+  push eax
+  push ecx
+  push edx
+  pushfd
+  mov eax, dword ptr [ebp + 8]
+  mov ecx, eax
+  shr ecx, 0x3
+  mov cl, byte ptr [ecx + 0x20000000]
+  test cl, cl
   je .sanitize_load1_done
-  movl %eax, %edx
-  andl $0x7, %edx
-  movsbl %cl, %ecx
-  cmpl %ecx, %edx
+  mov edx, eax
+  and edx, 0x7
+  movsx ecx, cl
+  cmp edx, ecx
   jl .sanitize_load1_done
-  pushl %eax
+  push eax
   cld
   emms
   call __asan_report_load1@PLT
 .sanitize_load1_done:
-  popfl
-  popl %edx
-  popl %ecx
-  popl %eax
+  popfd
+  pop edx
+  pop ecx
+  pop 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
+  push ebp
+  mov  ebp, esp
+  push eax
+  push ecx
+  push edx
+  pushfd
+  mov eax, dword ptr [ebp + 8]
+  mov ecx, eax
+  shr ecx, 0x3
+  mov cl, byte ptr [ecx + 0x20000000]
+  test cl, cl
   je .sanitize_store2_done
-  movl %eax, %edx
-  andl $0x7, %edx
-  incl %edx
-  movsbl %cl, %ecx
-  cmpl %ecx, %edx
+  mov edx, eax
+  and edx, 0x7
+  inc edx
+  movsx ecx, cl
+  cmp edx, ecx
   jl .sanitize_store2_done
-  pushl %eax
+  push eax
   cld
   emms
   call __asan_report_store2@PLT
 .sanitize_store2_done:
-  popfl
-  popl %edx
-  popl %ecx
-  popl %eax
+  popfd
+  pop edx
+  pop ecx
+  pop 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
+  push ebp
+  mov  ebp, esp
+  push eax
+  push ecx
+  push edx
+  pushfd
+  mov eax, dword ptr [ebp + 8]
+  mov ecx, eax
+  shr ecx, 0x3
+  mov cl, byte ptr [ecx + 0x20000000]
+  test cl, cl
   je .sanitize_load2_done
-  movl %eax, %edx
-  andl $0x7, %edx
-  incl %edx
-  movsbl %cl, %ecx
-  cmpl %ecx, %edx
+  mov edx, eax
+  and edx, 0x7
+  inc edx
+  movsx ecx, cl
+  cmp edx, ecx
   jl .sanitize_load2_done
-  pushl %eax
+  push eax
   cld
   emms
   call __asan_report_load2@PLT
 .sanitize_load2_done:
-  popfl
-  popl %edx
-  popl %ecx
-  popl %eax
+  popfd
+  pop edx
+  pop ecx
+  pop 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
+  push ebp
+  mov  ebp, esp
+  push eax
+  push ecx
+  push edx
+  pushfd
+  mov eax, dword ptr [ebp + 8]
+  mov ecx, eax
+  shr ecx, 0x3
+  mov cl, byte ptr [ecx + 0x20000000]
+  test cl, cl
   je .sanitize_store4_done
-  movl %eax, %edx
-  andl $0x7, %edx
-  addl $0x3, %edx
-  movsbl %cl, %ecx
-  cmpl %ecx, %edx
+  mov edx, eax
+  and edx, 0x7
+  add edx, 0x3
+  movsx ecx, cl
+  cmp edx, ecx
   jl .sanitize_store4_done
-  pushl %eax
+  push eax
   cld
   emms
   call __asan_report_store4@PLT
 .sanitize_store4_done:
-  popfl
-  popl %edx
-  popl %ecx
-  popl %eax
+  popfd
+  pop edx
+  pop ecx
+  pop 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
+  push ebp
+  mov  ebp, esp
+  push eax
+  push ecx
+  push edx
+  pushfd
+  mov eax, dword ptr [ebp + 8]
+  mov ecx, eax
+  shr ecx, 0x3
+  mov cl, byte ptr [ecx + 0x20000000]
+  test cl, cl
   je .sanitize_load4_done
-  movl %eax, %edx
-  andl $0x7, %edx
-  addl $0x3, %edx
-  movsbl %cl, %ecx
-  cmpl %ecx, %edx
+  mov edx, eax
+  and edx, 0x7
+  add edx, 0x3
+  movsx ecx, cl
+  cmp edx, ecx
   jl .sanitize_load4_done
-  pushl %eax
+  push eax
   cld
   emms
   call __asan_report_load4@PLT
 .sanitize_load4_done:
-  popfl
-  popl %edx
-  popl %ecx
-  popl %eax
+  popfd
+  pop edx
+  pop ecx
+  pop 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)
+  push ebp
+  mov ebp, esp
+  push eax
+  push ecx
+  pushfd
+  mov eax, dword ptr [ebp + 8]
+  mov ecx, eax
+  shr ecx, 0x3
+  cmp byte ptr [ecx + 0x20000000], 0x0
   je .sanitize_store8_done
-  pushl %eax
+  push eax
   cld
   emms
   call __asan_report_store8@PLT
 .sanitize_store8_done:
-  popfl
-  popl %ecx
-  popl %eax
+  popfd
+  pop ecx
+  pop 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)
+  push ebp
+  mov ebp, esp
+  push eax
+  push ecx
+  pushfd
+  mov eax, dword ptr [ebp + 8]
+  mov ecx, eax
+  shr ecx, 0x3
+  cmp byte ptr [ecx + 0x20000000], 0x0
   je .sanitize_load8_done
-  pushl %eax
+  push eax
   cld
   emms
   call __asan_report_load8@PLT
 .sanitize_load8_done:
-  popfl
-  popl %ecx
-  popl %eax
+  popfd
+  pop ecx
+  pop 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)
+  push ebp
+  mov ebp, esp
+  push eax
+  push ecx
+  pushfd
+  mov eax, dword ptr [ebp + 8]
+  mov ecx, eax
+  shr ecx, 0x3
+  cmp word ptr [ecx + 0x20000000], 0x0
   je .sanitize_store16_done
-  pushl %eax
+  push eax
   cld
   emms
   call __asan_report_store16@PLT
 .sanitize_store16_done:
-  popfl
-  popl %ecx
-  popl %eax
+  popfd
+  pop ecx
+  pop 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)
+  push ebp
+  mov ebp, esp
+  push eax
+  push ecx
+  pushfd
+  mov eax, dword ptr [ebp + 8]
+  mov ecx, eax
+  shr ecx, 0x3
+  cmp word ptr [ecx + 0x20000000], 0x0
   je .sanitize_load16_done
-  pushl %eax
+  push eax
   cld
   emms
   call __asan_report_load16@PLT
 .sanitize_load16_done:
-  popfl
-  popl %ecx
-  popl %eax
+  popfd
+  pop ecx
+  pop 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
+  sub rsp, 128
+  push rax
+  push rcx
   pushfq
-  movq %rdi, %rax
-  shrq $0x3, %rax
-  movb 0x7fff8000(%rax), %al
-  test %al, %al
+  mov rax, rdi
+  shr rax, 0x3
+  mov al, byte ptr [rax + 0x7fff8000]
+  test al, al
   je .sanitize_store1_done
-  movl %edi, %ecx
-  andl $0x7, %ecx
-  movsbl %al, %eax
-  cmpl %eax, %ecx
+  mov ecx, edi
+  and ecx, 0x7
+  movsx eax, al
+  cmp ecx, eax
   jl .sanitize_store1_done
-  subq $8, %rsp
-  andq $-16, %rsp
+  sub rsp, 8
+  and rsp, -16
   cld
   emms
   call __asan_report_store1@PLT
 .sanitize_store1_done:
   popfq
-  popq %rcx
-  popq %rax
-  addq $128, %rsp
+  pop rcx
+  pop rax
+  add rsp, 128
   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
+  sub rsp, 128
+  push rax
+  push rcx
   pushfq
-  movq %rdi, %rax
-  shrq $0x3, %rax
-  movb 0x7fff8000(%rax), %al
-  test %al, %al
+  mov rax, rdi
+  shr rax, 0x3
+  mov al, byte ptr [rax + 0x7fff8000]
+  test al, al
   je .sanitize_load1_done
-  movl %edi, %ecx
-  andl $0x7, %ecx
-  movsbl %al, %eax
-  cmpl %eax, %ecx
+  mov ecx, edi
+  and ecx, 0x7
+  movsx eax, al
+  cmp ecx, eax
   jl .sanitize_load1_done
-  subq $8, %rsp
-  andq $-16, %rsp
+  sub rsp, 8
+  and rsp, -16
   cld
   emms
   call __asan_report_load1@PLT
 .sanitize_load1_done:
   popfq
-  popq %rcx
-  popq %rax
-  addq $128, %rsp
+  pop rcx
+  pop rax
+  add rsp, 128
   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
+  sub rsp, 128
+  push rax
+  push rcx
   pushfq
-  movq %rdi, %rax
-  shrq $0x3, %rax
-  movb 0x7fff8000(%rax), %al
-  test %al, %al
+  mov rax, rdi
+  shr rax, 0x3
+  mov al, byte ptr [rax + 0x7fff8000]
+  test al, al
   je .sanitize_store2_done
-  movl %edi, %ecx
-  andl $0x7, %ecx
-  incl %ecx
-  movsbl %al, %eax
-  cmpl %eax, %ecx
+  mov ecx, edi
+  and ecx, 0x7
+  inc ecx
+  movsx eax, al
+  cmp ecx, eax
   jl .sanitize_store2_done
-  subq $8, %rsp
-  andq $-16, %rsp
+  sub rsp, 8
+  and rsp, -16
   cld
   emms
   call __asan_report_store2@PLT
 .sanitize_store2_done:
   popfq
-  popq %rcx
-  popq %rax
-  addq $128, %rsp
+  pop rcx
+  pop rax
+  add rsp, 128
   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
+  sub rsp, 128
+  push rax
+  push rcx
   pushfq
-  movq %rdi, %rax
-  shrq $0x3, %rax
-  movb 0x7fff8000(%rax), %al
-  test %al, %al
+  mov rax, rdi
+  shr rax, 0x3
+  mov al, byte ptr [rax + 0x7fff8000]
+  test al, al
   je .sanitize_load2_done
-  movl %edi, %ecx
-  andl $0x7, %ecx
-  incl %ecx
-  movsbl %al, %eax
-  cmpl %eax, %ecx
+  mov ecx, edi
+  and ecx, 0x7
+  inc ecx
+  movsx eax, al
+  cmp ecx, eax
   jl .sanitize_load2_done
-  subq $8, %rsp
-  andq $-16, %rsp
+  sub rsp, 8
+  and rsp, -16
   cld
   emms
   call __asan_report_load2@PLT
 .sanitize_load2_done:
   popfq
-  popq %rcx
-  popq %rax
-  addq $128, %rsp
+  pop rcx
+  pop rax
+  add rsp, 128
   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
+  sub rsp, 128
+  push rax
+  push rcx
   pushfq
-  movq %rdi, %rax
-  shrq $0x3, %rax
-  movb 0x7fff8000(%rax), %al
-  test %al, %al
+  mov rax, rdi
+  shr rax, 0x3
+  mov al, byte ptr [rax + 0x7fff8000]
+  test al, al
   je .sanitize_store4_done
-  movl %edi, %ecx
-  andl $0x7, %ecx
-  addl $0x3, %ecx
-  movsbl %al, %eax
-  cmpl %eax, %ecx
+  mov ecx, edi
+  and ecx, 0x7
+  add ecx, 0x3
+  movsx eax, al
+  cmp ecx, eax
   jl .sanitize_store4_done
-  subq $8, %rsp
-  andq $-16, %rsp
+  sub rsp, 8
+  and rsp, -16
   cld
   emms
   call __asan_report_store4@PLT
 .sanitize_store4_done:
   popfq
-  popq %rcx
-  popq %rax
-  addq $128, %rsp
+  pop rcx
+  pop rax
+  add rsp, 128
   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
+  sub rsp, 128
+  push rax
+  push rcx
   pushfq
-  movq %rdi, %rax
-  shrq $0x3, %rax
-  movb 0x7fff8000(%rax), %al
-  test %al, %al
+  mov rax, rdi
+  shr rax, 0x3
+  mov al, byte ptr [rax + 0x7fff8000]
+  test al, al
   je .sanitize_load4_done
-  movl %edi, %ecx
-  andl $0x7, %ecx
-  addl $0x3, %ecx
-  movsbl %al, %eax
-  cmpl %eax, %ecx
+  mov ecx, edi
+  and ecx, 0x7
+  add ecx, 0x3
+  movsx eax, al
+  cmp ecx, eax
   jl .sanitize_load4_done
-  subq $8, %rsp
-  andq $-16, %rsp
+  sub rsp, 8
+  and rsp, -16
   cld
   emms
   call __asan_report_load4@PLT
 .sanitize_load4_done:
   popfq
-  popq %rcx
-  popq %rax
-  addq $128, %rsp
+  pop rcx
+  pop rax
+  add rsp, 128
   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
+  sub rsp, 128
+  push rax
   pushfq
-  movq %rdi, %rax
-  shrq $0x3, %rax
-  cmpb $0x0, 0x7fff8000(%rax)
+  mov rax, rdi
+  shr rax, 0x3
+  cmp byte ptr [rax + 0x7fff8000], 0x0
   je .sanitize_store8_done
-  subq $8, %rsp
-  andq $-16, %rsp
+  sub rsp, 8
+  and rsp, -16
   cld
   emms
   call __asan_report_store8@PLT
 .sanitize_store8_done:
   popfq
-  popq %rax
-  addq $128, %rsp
+  pop rax
+  add rsp, 128
   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
+  sub rsp, 128
+  push rax
   pushfq
-  movq %rdi, %rax
-  shrq $0x3, %rax
-  cmpb $0x0, 0x7fff8000(%rax)
+  mov rax, rdi
+  shr rax, 0x3
+  cmp byte ptr [rax + 0x7fff8000], 0x0
   je .sanitize_load8_done
-  subq $8, %rsp
-  andq $-16, %rsp
+  sub rsp, 8
+  and rsp, -16
   cld
   emms
   call __asan_report_load8@PLT
 .sanitize_load8_done:
   popfq
-  popq %rax
-  addq $128, %rsp
+  pop rax
+  add rsp, 128
   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
+  sub rsp, 128
+  push rax
   pushfq
-  movq %rdi, %rax
-  shrq $0x3, %rax
-  cmpw $0x0, 0x7fff8000(%rax)
+  mov rax, rdi
+  shr rax, 0x3
+  cmp word ptr [rax + 0x7fff8000], 0x0
   je .sanitize_store16_done
-  subq $8, %rsp
-  andq $-16, %rsp
+  sub rsp, 8
+  and rsp, -16
   cld
   emms
   call __asan_report_store16@PLT
 .sanitize_store16_done:
   popfq
-  popq %rax
-  addq $128, %rsp
+  pop rax
+  add rsp, 128
   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
+  sub rsp, 128
+  push rax
   pushfq
-  movq %rdi, %rax
-  shrq $0x3, %rax
-  cmpw $0x0, 0x7fff8000(%rax)
+  mov rax, rdi
+  shr rax, 0x3
+  cmp word ptr [rax + 0x7fff8000], 0x0
   je .sanitize_load16_done
-  subq $8, %rsp
-  andq $-16, %rsp
+  sub rsp, 8
+  and rsp, -16
   cld
   emms
   call __asan_report_load16@PLT
 .sanitize_load16_done:
   popfq
-  popq %rax
-  addq $128, %rsp
+  pop rax
+  add rsp, 128
   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__

lib/asan/scripts/gen_asm_instrumentation.sh

cat <<EOF
   cld
   emms
   call $(func_report $1 $2)@PLT
 EOF
 }
 
 emit_stack_align() {
 cat <<EOF
-  subq \$8, %rsp
-  andq \$-16, %rsp
+  sub rsp, 8
+  and rsp, -16
 EOF
 }
 
 cat <<EOF
 // This file was generated by $(basename $0). Please, do not edit
 // manually.
 EOF
 
 echo "#ifdef __linux__"
+echo ".intel_syntax noprefix;"
 echo ".section .text"
 
 echo "#if defined(__x86_64__) || defined(__i386__)"
 for as in 1 2 4 8 16
 do
   for at in store load
   do
     echo ".globl $(func_report $at $as)"
do
   for at in store load
   do
 cat <<EOF
 // Sanitize $as-byte $at. Takes one 4-byte address as an argument on
 // stack, nothing is returned.
 .globl $(func_name $at $as)
 .type $(func_name $at $as), @function
 $(func_name $at $as):
-  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
+  push ebp
+  mov  ebp, esp
+  push eax
+  push ecx
+  push edx
+  pushfd
+  mov eax, dword ptr [ebp + 8]
+  mov ecx, eax
+  shr ecx, 0x3
+  mov cl, byte ptr [ecx + 0x20000000]
+  test cl, cl
   je $(func_label $at $as)
-  movl %eax, %edx
-  andl \$0x7, %edx
+  mov edx, eax
+  and edx, 0x7
 EOF
 
     case $as in
     1) ;;
-    2) echo '  incl %edx' ;;
-    4) echo '  addl $0x3, %edx' ;;
+    2) echo '  inc edx' ;;
+    4) echo '  add edx, 0x3' ;;
     *) echo "Incorrect access size: $as" 1>&2; exit 1 ;;
     esac
 
 cat <<EOF
-  movsbl %cl, %ecx
-  cmpl %ecx, %edx
+  movsx ecx, cl
+  cmp edx, ecx
   jl $(func_label $at $as)
-  pushl %eax
+  push eax
 $(emit_call_report $at $as)
 $(func_label $at $as):
-  popfl
-  popl %edx
-  popl %ecx
-  popl %eax
+  popfd
+  pop edx
+  pop ecx
+  pop eax
   leave
   ret
 EOF
   done
 done
 
 # Functions for i386 8- and 16-byte accesses.
 for as in 8 16
 do
   for at in store load
   do
 cat <<EOF
 // Sanitize $as-byte $at. Takes one 4-byte address as an argument on
 // stack, nothing is returned.
 .globl $(func_name $at $as)
 .type $(func_name $at $as), @function
 $(func_name $at $as):
-  pushl %ebp
-  movl %esp, %ebp
-  pushl %eax
-  pushl %ecx
-  pushfl
-  movl 8(%ebp), %eax
-  movl %eax, %ecx
-  shrl \$0x3, %ecx
+  push ebp
+  mov ebp, esp
+  push eax
+  push ecx
+  pushfd
+  mov eax, dword ptr [ebp + 8]
+  mov ecx, eax
+  shr ecx, 0x3
 EOF
 
     case ${as} in
-      8) echo '  cmpb $0x0, 0x20000000(%ecx)' ;;
-     16) echo '  cmpw $0x0, 0x20000000(%ecx)' ;;
+      8) echo '  cmp byte ptr [ecx + 0x20000000], 0x0' ;;
+     16) echo '  cmp word ptr [ecx + 0x20000000], 0x0' ;;
       *) echo "Incorrect access size: ${as}" 1>&2; exit 1 ;;
     esac
 
 cat <<EOF
   je $(func_label $at $as)
-  pushl %eax
+  push eax
 $(emit_call_report $at $as)
 $(func_label $at $as):
-  popfl
-  popl %ecx
-  popl %eax
+  popfd
+  pop ecx
+  pop eax
   leave
   ret
 EOF
   done
 done
 
 echo "#endif // defined(__i386__)"
 
 echo "#if defined(__x86_64__)"
 
 # Functions for x86-64 1-, 2- and 4-byte accesses.
 for as in 1 2 4
 do
   for at in store load
   do
 cat <<EOF
 // Sanitize $as-byte $at. Takes one 8-byte address as an argument in %rdi,
 // nothing is returned.
 .globl $(func_name $at $as)
 .type $(func_name $at $as), @function
 $(func_name $at $as):
-  subq \$128, %rsp
-  pushq %rax
-  pushq %rcx
+  sub rsp, 128
+  push rax
+  push rcx
   pushfq
-  movq %rdi, %rax
-  shrq \$0x3, %rax
-  movb 0x7fff8000(%rax), %al
-  test %al, %al
+  mov rax, rdi
+  shr rax, 0x3
+  mov al, byte ptr [rax + 0x7fff8000]
+  test al, al
   je $(func_label $at $as)
-  movl %edi, %ecx
-  andl \$0x7, %ecx
+  mov ecx, edi
+  and ecx, 0x7
 EOF
 
     case ${as} in
     1) ;;
-    2) echo '  incl %ecx' ;;
-    4) echo '  addl $0x3, %ecx' ;;
+    2) echo '  inc ecx' ;;
+    4) echo '  add ecx, 0x3' ;;
     *) echo "Incorrect access size: ${as}" 1>&2; exit 1 ;;
     esac
 
 cat <<EOF
-  movsbl %al, %eax
-  cmpl %eax, %ecx
+  movsx eax, al
+  cmp ecx, eax
   jl $(func_label $at $as)
 $(emit_stack_align)
 $(emit_call_report $at $as)
 $(func_label $at $as):
   popfq
-  popq %rcx
-  popq %rax
-  addq \$128, %rsp
+  pop rcx
+  pop rax
+  add rsp, 128
   ret
 EOF
   done
 done
 
 # Functions for x86-64 8- and 16-byte accesses.
 for as in 8 16
 do
   for at in store load
   do
 cat <<EOF
 // Sanitize $as-byte $at. Takes one 8-byte address as an argument in %rdi,
 // nothing is returned.
 .globl $(func_name $at $as)
 .type $(func_name $at $as), @function
 $(func_name $at $as):
-  subq \$128, %rsp
-  pushq %rax
+  sub rsp, 128
+  push rax
   pushfq
-  movq %rdi, %rax
-  shrq \$0x3, %rax
+  mov rax, rdi
+  shr rax, 0x3
 EOF
 
     case ${as} in
-      8) echo '  cmpb $0x0, 0x7fff8000(%rax)' ;;
-     16) echo '  cmpw $0x0, 0x7fff8000(%rax)' ;;
+      8) echo '  cmp byte ptr [rax + 0x7fff8000], 0x0' ;;
+     16) echo '  cmp word ptr [rax + 0x7fff8000], 0x0' ;;
       *) echo "Incorrect access size: ${as}" 1>&2; exit 1 ;;
     esac
 
 cat <<EOF
   je $(func_label $at $as)
 $(emit_stack_align)
 $(emit_call_report $at $as)
 $(func_label $at $as):
   popfq
-  popq %rax
-  addq \$128, %rsp
+  pop rax
+  add rsp, 128
   ret
 EOF
   done
 done
 echo "#endif // defined(__x86_64__)"
 
 cat <<EOF
 /* 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__
 EOF