[sanitizer] Refactor how assembly files are handled

[kubamracek]

Summary

This renames ASM_TSAN_SYMBOL and ASM_TSAN_SYMBOL_INTERCEPTOR to just ASM_SYMBOL and ASM_SYMBOL_INTERCEPTOR, because they can be useful in more places than just TSan. Also introduce a CMake function to add ASM sources to a target.

[fjricci]

Lgtm

[dberris]

LGTM

cmake/Modules/AddCompilerRT.cmake

function(add_compiler_rt_component name)
   add_custom_target(${name})
   set_target_properties(${name} PROPERTIES FOLDER "Compiler-RT Misc")
   if(COMMAND runtime_register_component)
     runtime_register_component(${name})
   endif()
   add_dependencies(compiler-rt ${name})
 endfunction()
 
+function(add_asm_sources output)
+  set(${output} ${ARGN} PARENT_SCOPE)
+  # Xcode will try to compile asm files as C ('clang -x c'), and that will fail.
+  if (${CMAKE_GENERATOR} STREQUAL "Xcode")
+    enable_language(ASM)
+  else()
+    # Pass ASM file directly to the C++ compiler.
+    set_source_files_properties(${ARGN} PROPERTIES LANGUAGE C)
+  endif()
+endfunction()
+
 macro(set_output_name output name arch)
   if(ANDROID AND ${arch} STREQUAL "i386")
     set(${output} "${name}-i686${COMPILER_RT_OS_SUFFIX}")
   else()
     set(${output} "${name}-${arch}${COMPILER_RT_OS_SUFFIX}")
   endif()
 endmacro()
 

lib/sanitizer_common/sanitizer_asm.h

 # define CFI_DEF_CFA(reg, n)
 # define CFI_RESTORE(reg)
 #endif
 
 #if !defined(__APPLE__)
 # define ASM_HIDDEN(symbol) .hidden symbol
 # define ASM_TYPE_FUNCTION(symbol) .type symbol, @function
 # define ASM_SIZE(symbol) .size symbol, .-symbol
-# define ASM_TSAN_SYMBOL(symbol) symbol
-# define ASM_TSAN_SYMBOL_INTERCEPTOR(symbol) symbol
+# define ASM_SYMBOL(symbol) symbol
+# define ASM_SYMBOL_INTERCEPTOR(symbol) symbol
 #else
 # define ASM_HIDDEN(symbol)
 # define ASM_TYPE_FUNCTION(symbol)
 # define ASM_SIZE(symbol)
-# define ASM_TSAN_SYMBOL(symbol) _##symbol
-# define ASM_TSAN_SYMBOL_INTERCEPTOR(symbol) _wrap_##symbol
+# define ASM_SYMBOL(symbol) _##symbol
+# define ASM_SYMBOL_INTERCEPTOR(symbol) _wrap_##symbol
 #endif

lib/tsan/CMakeLists.txt

set(TSAN_HEADERS
   rtl/tsan_trace.h
   rtl/tsan_update_shadow_word_inl.h
   rtl/tsan_vector.h)
 
 set(TSAN_RUNTIME_LIBRARIES)
 add_compiler_rt_component(tsan)
 
 if(APPLE)
-  set(TSAN_ASM_SOURCES rtl/tsan_rtl_amd64.S rtl/tsan_rtl_aarch64.S)
-  # Xcode will try to compile this file as C ('clang -x c'), and that will fail.
-  if (${CMAKE_GENERATOR} STREQUAL "Xcode")
-    enable_language(ASM)
-  else()
-    # Pass ASM file directly to the C++ compiler.
-    set_source_files_properties(${TSAN_ASM_SOURCES} PROPERTIES LANGUAGE C)
-  endif()
+  add_asm_sources(TSAN_ASM_SOURCES rtl/tsan_rtl_amd64.S rtl/tsan_rtl_aarch64.S)
 
   set(TSAN_LINK_LIBS ${SANITIZER_COMMON_LINK_LIBS})
 
   add_weak_symbols("ubsan" WEAK_SYMBOL_LINK_FLAGS)
   add_weak_symbols("sanitizer_common" WEAK_SYMBOL_LINK_FLAGS)
 
   add_compiler_rt_runtime(clang_rt.tsan
     SHARED
COMMAND env "CC=${CMAKE_C_COMPILER} ${OSX_SYSROOT_FLAG}"
             IN_TMPDIR=1 SILENT=1 ${BUILDGO_SCRIPT}
     DEPENDS tsan ${BUILDGO_SCRIPT}
     WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/go
     COMMENT "Checking TSan Go runtime..."
     VERBATIM)
 else()
   foreach(arch ${TSAN_SUPPORTED_ARCH})
     if(arch STREQUAL "x86_64")
-      set(TSAN_ASM_SOURCES rtl/tsan_rtl_amd64.S)
-      # Pass ASM file directly to the C++ compiler.
-      set_source_files_properties(${TSAN_ASM_SOURCES} PROPERTIES
-        LANGUAGE C)
+      add_asm_sources(TSAN_ASM_SOURCES rtl/tsan_rtl_amd64.S)
       # Sanity check for Go runtime.
       set(BUILDGO_SCRIPT ${CMAKE_CURRENT_SOURCE_DIR}/go/buildgo.sh)
       add_custom_target(GotsanRuntimeCheck
         COMMAND env "CC=${CMAKE_C_COMPILER} ${CMAKE_C_COMPILER_ARG1}"
                 IN_TMPDIR=1 SILENT=1 ${BUILDGO_SCRIPT}
         DEPENDS clang_rt.tsan-${arch} ${BUILDGO_SCRIPT}
         WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/go
         COMMENT "Checking TSan Go runtime..."
         VERBATIM)
     elseif(arch STREQUAL "aarch64")
-      set(TSAN_ASM_SOURCES rtl/tsan_rtl_aarch64.S)
-      # Pass ASM file directly to the C++ compiler.
-      set_source_files_properties(${TSAN_ASM_SOURCES} PROPERTIES
-        LANGUAGE C)
+      add_asm_sources(TSAN_ASM_SOURCES rtl/tsan_rtl_aarch64.S)
     elseif(arch MATCHES "powerpc64|powerpc64le")
-     set(TSAN_ASM_SOURCES rtl/tsan_rtl_ppc64.S)
-     # Pass ASM file directly to the C++ compiler.
-     set_source_files_properties(${TSAN_ASM_SOURCES} PROPERTIES
-       LANGUAGE C)
+      add_asm_sources(TSAN_ASM_SOURCES rtl/tsan_rtl_ppc64.S)
     elseif(arch MATCHES "mips64|mips64le")
-     set(TSAN_ASM_SOURCES rtl/tsan_rtl_mips64.S)
-     # Pass ASM file directly to the C++ compiler.
-     set_source_files_properties(${TSAN_ASM_SOURCES} PROPERTIES
-       LANGUAGE C)
+      add_asm_sources(TSAN_ASM_SOURCES rtl/tsan_rtl_mips64.S)
     else()
       set(TSAN_ASM_SOURCES)
     endif()
     add_compiler_rt_runtime(clang_rt.tsan
       STATIC
       ARCHS ${arch}
       SOURCES ${TSAN_SOURCES} ${TSAN_ASM_SOURCES}
               $<TARGET_OBJECTS:RTInterception.${arch}>

lib/tsan/rtl/tsan_rtl_aarch64.S

 // The content of this file is AArch64-only:
 #if defined(__aarch64__)
 
 #include "sanitizer_common/sanitizer_asm.h"
 
 #if !defined(__APPLE__)
 .section .bss
 .type __tsan_pointer_chk_guard, %object
-ASM_SIZE(ASM_TSAN_SYMBOL_INTERCEPTOR(__tsan_pointer_chk_guard))
+ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(__tsan_pointer_chk_guard))
 __tsan_pointer_chk_guard:
 .zero 8
 #endif
 
 #if defined(__APPLE__)
 .align  2
 
 .section  __DATA,__nl_symbol_ptr,non_lazy_symbol_pointers

 // global variable rather than a TCB one (as for x86_64/powerpc) and althought
 // its value is exported by the loader, it lies within a private GLIBC
 // namespace (meaning it should be only used by GLIBC itself and the ABI is
 // not stable). So InitializeGuardPtr obtains the pointer guard value by
 // issuing a setjmp and checking the resulting pointers values against the
 // original ones.
 ASM_HIDDEN(_Z18InitializeGuardPtrv)
 .global _Z18InitializeGuardPtrv
-ASM_TYPE_FUNCTION(ASM_TSAN_SYMBOL_INTERCEPTOR(_Z18InitializeGuardPtrv))
+ASM_TYPE_FUNCTION(ASM_SYMBOL_INTERCEPTOR(_Z18InitializeGuardPtrv))
 _Z18InitializeGuardPtrv:
   CFI_STARTPROC
   // Allocates a jmp_buf for the setjmp call.
   stp  x29, x30, [sp, -336]!
   CFI_DEF_CFA_OFFSET (336)
   CFI_OFFSET (29, -336)
   CFI_OFFSET (30, -328)
   add x29, sp, 0
_Z18InitializeGuardPtrv:
   adrp  x2, __tsan_pointer_chk_guard
   str x0, [x2, #:lo12:__tsan_pointer_chk_guard]
   ldp x29, x30, [sp], 336
   CFI_RESTORE (30)
   CFI_RESTORE (19)
   CFI_DEF_CFA (31, 0)
   ret
   CFI_ENDPROC
-ASM_SIZE(ASM_TSAN_SYMBOL_INTERCEPTOR(_Z18InitializeGuardPtrv))
+ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(_Z18InitializeGuardPtrv))
 #endif
 
 ASM_HIDDEN(__tsan_setjmp)
 .comm _ZN14__interception11real_setjmpE,8,8
-.globl ASM_TSAN_SYMBOL_INTERCEPTOR(setjmp)
-ASM_TYPE_FUNCTION(ASM_TSAN_SYMBOL_INTERCEPTOR(setjmp))
-ASM_TSAN_SYMBOL_INTERCEPTOR(setjmp):
+.globl ASM_SYMBOL_INTERCEPTOR(setjmp)
+ASM_TYPE_FUNCTION(ASM_SYMBOL_INTERCEPTOR(setjmp))
+ASM_SYMBOL_INTERCEPTOR(setjmp):
   CFI_STARTPROC
 
   // save env parameters for function call
   stp     x29, x30, [sp, -32]!
   CFI_DEF_CFA_OFFSET (32)
   CFI_OFFSET (29, -32)
   CFI_OFFSET (30, -24)
 
#if !defined(__APPLE__)
   add     x0, x29, 32
   eor     x1, x2, x0
 #else
   add     x0, x29, 32
   mov     x1, x0
 #endif
 
   // call tsan interceptor
-  bl      ASM_TSAN_SYMBOL(__tsan_setjmp)
+  bl      ASM_SYMBOL(__tsan_setjmp)
 
   // restore env parameter
   mov     x0, x19
   ldr     x19, [sp, 16]
   ldp     x29, x30, [sp], 32
   CFI_RESTORE (30)
   CFI_RESTORE (19)
   CFI_DEF_CFA (31, 0)
 
   // tail jump to libc setjmp
 #if !defined(__APPLE__)
   adrp    x1, :got:_ZN14__interception11real_setjmpE
   ldr     x1, [x1, #:got_lo12:_ZN14__interception11real_setjmpE]
   ldr     x1, [x1]
 #else
   adrp    x1, _setjmp$non_lazy_ptr@page
   add     x1, x1, _setjmp$non_lazy_ptr@pageoff
   ldr     x1, [x1]
 #endif
   br      x1
 
   CFI_ENDPROC
-ASM_SIZE(ASM_TSAN_SYMBOL_INTERCEPTOR(setjmp))
+ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(setjmp))
 
 .comm _ZN14__interception12real__setjmpE,8,8
-.globl ASM_TSAN_SYMBOL_INTERCEPTOR(_setjmp)
-ASM_TYPE_FUNCTION(ASM_TSAN_SYMBOL_INTERCEPTOR(_setjmp))
-ASM_TSAN_SYMBOL_INTERCEPTOR(_setjmp):
+.globl ASM_SYMBOL_INTERCEPTOR(_setjmp)
+ASM_TYPE_FUNCTION(ASM_SYMBOL_INTERCEPTOR(_setjmp))
+ASM_SYMBOL_INTERCEPTOR(_setjmp):
   CFI_STARTPROC
 
   // save env parameters for function call
   stp     x29, x30, [sp, -32]!
   CFI_DEF_CFA_OFFSET (32)
   CFI_OFFSET (29, -32)
   CFI_OFFSET (30, -24)
 
#if !defined(__APPLE__)
   add     x0, x29, 32
   eor     x1, x2, x0
 #else
   add     x0, x29, 32
   mov     x1, x0
 #endif
 
   // call tsan interceptor
-  bl      ASM_TSAN_SYMBOL(__tsan_setjmp)
+  bl      ASM_SYMBOL(__tsan_setjmp)
 
   // Restore jmp_buf parameter
   mov     x0, x19
   ldr     x19, [sp, 16]
   ldp     x29, x30, [sp], 32
   CFI_RESTORE (30)
   CFI_RESTORE (19)
   CFI_DEF_CFA (31, 0)
 
   // tail jump to libc setjmp
 #if !defined(__APPLE__)
   adrp    x1, :got:_ZN14__interception12real__setjmpE
   ldr     x1, [x1, #:got_lo12:_ZN14__interception12real__setjmpE]
   ldr     x1, [x1]
 #else
   adrp    x1, __setjmp$non_lazy_ptr@page
   add     x1, x1, __setjmp$non_lazy_ptr@pageoff
   ldr     x1, [x1]
 #endif
   br      x1
 
   CFI_ENDPROC
-ASM_SIZE(ASM_TSAN_SYMBOL_INTERCEPTOR(_setjmp))
+ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(_setjmp))
 
 .comm _ZN14__interception14real_sigsetjmpE,8,8
-.globl ASM_TSAN_SYMBOL_INTERCEPTOR(sigsetjmp)
-ASM_TYPE_FUNCTION(ASM_TSAN_SYMBOL_INTERCEPTOR(sigsetjmp))
-ASM_TSAN_SYMBOL_INTERCEPTOR(sigsetjmp):
+.globl ASM_SYMBOL_INTERCEPTOR(sigsetjmp)
+ASM_TYPE_FUNCTION(ASM_SYMBOL_INTERCEPTOR(sigsetjmp))
+ASM_SYMBOL_INTERCEPTOR(sigsetjmp):
   CFI_STARTPROC
 
   // save env parameters for function call
   stp     x29, x30, [sp, -32]!
   CFI_DEF_CFA_OFFSET (32)
   CFI_OFFSET (29, -32)
   CFI_OFFSET (30, -24)
 
#if !defined(__APPLE__)
   add     x0, x29, 32
   eor     x1, x2, x0
 #else
   add     x0, x29, 32
   mov     x1, x0
 #endif
 
   // call tsan interceptor
-  bl      ASM_TSAN_SYMBOL(__tsan_setjmp)
+  bl      ASM_SYMBOL(__tsan_setjmp)
 
   // restore env parameter
   mov     w1, w20
   mov     x0, x19
   ldp     x19, x20, [sp, 16]
   ldp     x29, x30, [sp], 32
   CFI_RESTORE (30)
   CFI_RESTORE (29)
   CFI_RESTORE (19)
   CFI_RESTORE (20)
   CFI_DEF_CFA (31, 0)
 
   // tail jump to libc sigsetjmp
 #if !defined(__APPLE__)
   adrp    x2, :got:_ZN14__interception14real_sigsetjmpE
   ldr     x2, [x2, #:got_lo12:_ZN14__interception14real_sigsetjmpE]
   ldr     x2, [x2]
 #else
   adrp    x2, _sigsetjmp$non_lazy_ptr@page
   add     x2, x2, _sigsetjmp$non_lazy_ptr@pageoff
   ldr     x2, [x2]
 #endif
   br      x2
   CFI_ENDPROC
-ASM_SIZE(ASM_TSAN_SYMBOL_INTERCEPTOR(sigsetjmp))
+ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(sigsetjmp))
 
 #if !defined(__APPLE__)
 .comm _ZN14__interception16real___sigsetjmpE,8,8
-.globl ASM_TSAN_SYMBOL_INTERCEPTOR(__sigsetjmp)
-ASM_TYPE_FUNCTION(ASM_TSAN_SYMBOL_INTERCEPTOR(__sigsetjmp))
-ASM_TSAN_SYMBOL_INTERCEPTOR(__sigsetjmp):
+.globl ASM_SYMBOL_INTERCEPTOR(__sigsetjmp)
+ASM_TYPE_FUNCTION(ASM_SYMBOL_INTERCEPTOR(__sigsetjmp))
+ASM_SYMBOL_INTERCEPTOR(__sigsetjmp):
   CFI_STARTPROC
 
   // save env parameters for function call
   stp     x29, x30, [sp, -32]!
   CFI_DEF_CFA_OFFSET (32)
   CFI_OFFSET (29, -32)
   CFI_OFFSET (30, -24)
 
#if !defined(__APPLE__)
   // SP pointer mangling (see glibc setjmp)
   adrp    x2, __tsan_pointer_chk_guard
   ldr     x2, [x2, #:lo12:__tsan_pointer_chk_guard]
   add     x0, x29, 32
   eor     x1, x2, x0
 #endif
 
   // call tsan interceptor
-  bl      ASM_TSAN_SYMBOL(__tsan_setjmp)
+  bl      ASM_SYMBOL(__tsan_setjmp)
 
   mov     w1, w20
   mov     x0, x19
   ldp     x19, x20, [sp, 16]
   ldp     x29, x30, [sp], 32
   CFI_RESTORE (30)
   CFI_RESTORE (29)
   CFI_RESTORE (19)
   CFI_RESTORE (20)
   CFI_DEF_CFA (31, 0)
 
   // tail jump to libc __sigsetjmp
 #if !defined(__APPLE__)
   adrp    x2, :got:_ZN14__interception16real___sigsetjmpE
   ldr     x2, [x2, #:got_lo12:_ZN14__interception16real___sigsetjmpE]
   ldr     x2, [x2]
 #else
-  adrp    x2, ASM_TSAN_SYMBOL(__sigsetjmp)@page
-  add     x2, x2, ASM_TSAN_SYMBOL(__sigsetjmp)@pageoff
+  adrp    x2, ASM_SYMBOL(__sigsetjmp)@page
+  add     x2, x2, ASM_SYMBOL(__sigsetjmp)@pageoff
 #endif
   br      x2
   CFI_ENDPROC
-ASM_SIZE(ASM_TSAN_SYMBOL_INTERCEPTOR(__sigsetjmp))
+ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(__sigsetjmp))
 #endif
 
 #if defined(__linux__)
 /* We do not need executable stack.  */
 .section        .note.GNU-stack,"",@progbits
 #endif
 
 #endif

lib/tsan/rtl/tsan_rtl_amd64.S

 // The content of this file is x86_64-only:
 #if defined(__x86_64__)
 
 #include "sanitizer_common/sanitizer_asm.h"
 
 #if !defined(__APPLE__)
 .section .text
 #else
 .section __TEXT,__text
 #endif
 
 ASM_HIDDEN(__tsan_trace_switch)
-.globl ASM_TSAN_SYMBOL(__tsan_trace_switch_thunk)
-ASM_TSAN_SYMBOL(__tsan_trace_switch_thunk):
+.globl ASM_SYMBOL(__tsan_trace_switch_thunk)
+ASM_SYMBOL(__tsan_trace_switch_thunk):
   CFI_STARTPROC
   # Save scratch registers.
   push %rax
   CFI_ADJUST_CFA_OFFSET(8)
   CFI_REL_OFFSET(%rax, 0)
   push %rcx
   CFI_ADJUST_CFA_OFFSET(8)
   CFI_REL_OFFSET(%rcx, 0)
ASM_SYMBOL(__tsan_trace_switch_thunk):
   push %rbx  # non-scratch
   CFI_ADJUST_CFA_OFFSET(8)
   CFI_REL_OFFSET(%rbx, 0)
   mov %rsp, %rbx  # save current rsp
   CFI_DEF_CFA_REGISTER(%rbx)
   shr $4, %rsp  # clear 4 lsb, align to 16
   shl $4, %rsp
 
-  call ASM_TSAN_SYMBOL(__tsan_trace_switch)
+  call ASM_SYMBOL(__tsan_trace_switch)
 
   # Unalign stack frame back.
   mov %rbx, %rsp  # restore the original rsp
   CFI_DEF_CFA_REGISTER(%rsp)
   pop %rbx
   CFI_ADJUST_CFA_OFFSET(-8)
   # Restore scratch registers.
   pop %r11
ASM_SYMBOL(__tsan_trace_switch_thunk):
   CFI_RESTORE(%r8)
   CFI_RESTORE(%r9)
   CFI_RESTORE(%r10)
   CFI_RESTORE(%r11)
   ret
   CFI_ENDPROC
 
 ASM_HIDDEN(__tsan_report_race)
-.globl ASM_TSAN_SYMBOL(__tsan_report_race_thunk)
-ASM_TSAN_SYMBOL(__tsan_report_race_thunk):
+.globl ASM_SYMBOL(__tsan_report_race_thunk)
+ASM_SYMBOL(__tsan_report_race_thunk):
   CFI_STARTPROC
   # Save scratch registers.
   push %rax
   CFI_ADJUST_CFA_OFFSET(8)
   CFI_REL_OFFSET(%rax, 0)
   push %rcx
   CFI_ADJUST_CFA_OFFSET(8)
   CFI_REL_OFFSET(%rcx, 0)
ASM_SYMBOL(__tsan_report_race_thunk):
   push %rbx  # non-scratch
   CFI_ADJUST_CFA_OFFSET(8)
   CFI_REL_OFFSET(%rbx, 0)
   mov %rsp, %rbx  # save current rsp
   CFI_DEF_CFA_REGISTER(%rbx)
   shr $4, %rsp  # clear 4 lsb, align to 16
   shl $4, %rsp
 
-  call ASM_TSAN_SYMBOL(__tsan_report_race)
+  call ASM_SYMBOL(__tsan_report_race)
 
   # Unalign stack frame back.
   mov %rbx, %rsp  # restore the original rsp
   CFI_DEF_CFA_REGISTER(%rsp)
   pop %rbx
   CFI_ADJUST_CFA_OFFSET(-8)
   # Restore scratch registers.
   pop %r11

 
 ASM_HIDDEN(__tsan_setjmp)
 #if defined(__NetBSD__)
 .comm _ZN14__interception15real___setjmp14E,8,8
 #elif !defined(__APPLE__)
 .comm _ZN14__interception11real_setjmpE,8,8
 #endif
 #if defined(__NetBSD__)
-.globl ASM_TSAN_SYMBOL_INTERCEPTOR(__setjmp14)
-ASM_TYPE_FUNCTION(ASM_TSAN_SYMBOL_INTERCEPTOR(__setjmp14))
-ASM_TSAN_SYMBOL_INTERCEPTOR(__setjmp14):
-#else
-.globl ASM_TSAN_SYMBOL_INTERCEPTOR(setjmp)
-ASM_TYPE_FUNCTION(ASM_TSAN_SYMBOL_INTERCEPTOR(setjmp))
-ASM_TSAN_SYMBOL_INTERCEPTOR(setjmp):
+.globl ASM_SYMBOL_INTERCEPTOR(__setjmp14)
+ASM_TYPE_FUNCTION(ASM_SYMBOL_INTERCEPTOR(__setjmp14))
+ASM_SYMBOL_INTERCEPTOR(__setjmp14):
+#else
+.globl ASM_SYMBOL_INTERCEPTOR(setjmp)
+ASM_TYPE_FUNCTION(ASM_SYMBOL_INTERCEPTOR(setjmp))
+ASM_SYMBOL_INTERCEPTOR(setjmp):
 #endif
   CFI_STARTPROC
   // save env parameter
   push %rdi
   CFI_ADJUST_CFA_OFFSET(8)
   CFI_REL_OFFSET(%rdi, 0)
   // obtain %rsp
 #if defined(__FreeBSD__) || defined(__NetBSD__)
   lea 8(%rsp), %rdi
   mov %rdi, %rsi
 #elif defined(__APPLE__)
   lea 16(%rsp), %rdi
   mov %rdi, %rsi
 #elif defined(__linux__)
   lea 16(%rsp), %rdi
   mov %rdi, %rsi
   xor %fs:0x30, %rsi  // magic mangling of rsp (see libc setjmp)
   rol $0x11, %rsi
 #else
 # error "Unknown platform"
 #endif
   // call tsan interceptor
-  call ASM_TSAN_SYMBOL(__tsan_setjmp)
+  call ASM_SYMBOL(__tsan_setjmp)
   // restore env parameter
   pop %rdi
   CFI_ADJUST_CFA_OFFSET(-8)
   CFI_RESTORE(%rdi)
   // tail jump to libc setjmp
   movl $0, %eax
 #if defined(__NetBSD__)
   movq _ZN14__interception15real___setjmp14E@GOTPCREL(%rip), %rdx
   jmp *(%rdx)
 #elif !defined(__APPLE__)
   movq _ZN14__interception11real_setjmpE@GOTPCREL(%rip), %rdx
   jmp *(%rdx)
 #else
-  jmp ASM_TSAN_SYMBOL(setjmp)
+  jmp ASM_SYMBOL(setjmp)
 #endif
   CFI_ENDPROC
 #if defined(__NetBSD__)
-ASM_SIZE(ASM_TSAN_SYMBOL_INTERCEPTOR(__setjmp14))
+ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(__setjmp14))
 #else
-ASM_SIZE(ASM_TSAN_SYMBOL_INTERCEPTOR(setjmp))
+ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(setjmp))
 #endif
 
 .comm _ZN14__interception12real__setjmpE,8,8
-.globl ASM_TSAN_SYMBOL_INTERCEPTOR(_setjmp)
-ASM_TYPE_FUNCTION(ASM_TSAN_SYMBOL_INTERCEPTOR(_setjmp))
-ASM_TSAN_SYMBOL_INTERCEPTOR(_setjmp):
+.globl ASM_SYMBOL_INTERCEPTOR(_setjmp)
+ASM_TYPE_FUNCTION(ASM_SYMBOL_INTERCEPTOR(_setjmp))
+ASM_SYMBOL_INTERCEPTOR(_setjmp):
   CFI_STARTPROC
   // save env parameter
   push %rdi
   CFI_ADJUST_CFA_OFFSET(8)
   CFI_REL_OFFSET(%rdi, 0)
   // obtain %rsp
 #if defined(__FreeBSD__) || defined(__NetBSD__)
   lea 8(%rsp), %rdi
   mov %rdi, %rsi
 #elif defined(__APPLE__)
   lea 16(%rsp), %rdi
   mov %rdi, %rsi
 #elif defined(__linux__)
   lea 16(%rsp), %rdi
   mov %rdi, %rsi
   xor %fs:0x30, %rsi  // magic mangling of rsp (see libc setjmp)
   rol $0x11, %rsi
 #else
 # error "Unknown platform"
 #endif
   // call tsan interceptor
-  call ASM_TSAN_SYMBOL(__tsan_setjmp)
+  call ASM_SYMBOL(__tsan_setjmp)
   // restore env parameter
   pop %rdi
   CFI_ADJUST_CFA_OFFSET(-8)
   CFI_RESTORE(%rdi)
   // tail jump to libc setjmp
   movl $0, %eax
 #if !defined(__APPLE__)
   movq _ZN14__interception12real__setjmpE@GOTPCREL(%rip), %rdx
   jmp *(%rdx)
 #else
-  jmp ASM_TSAN_SYMBOL(_setjmp)
+  jmp ASM_SYMBOL(_setjmp)
 #endif
   CFI_ENDPROC
-ASM_SIZE(ASM_TSAN_SYMBOL_INTERCEPTOR(_setjmp))
+ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(_setjmp))
 
 #if defined(__NetBSD__)
 .comm _ZN14__interception18real___sigsetjmp14E,8,8
-.globl ASM_TSAN_SYMBOL_INTERCEPTOR(__sigsetjmp14)
-ASM_TYPE_FUNCTION(ASM_TSAN_SYMBOL_INTERCEPTOR(__sigsetjmp14))
-ASM_TSAN_SYMBOL_INTERCEPTOR(__sigsetjmp14):
+.globl ASM_SYMBOL_INTERCEPTOR(__sigsetjmp14)
+ASM_TYPE_FUNCTION(ASM_SYMBOL_INTERCEPTOR(__sigsetjmp14))
+ASM_SYMBOL_INTERCEPTOR(__sigsetjmp14):
 #else
 .comm _ZN14__interception14real_sigsetjmpE,8,8
-.globl ASM_TSAN_SYMBOL_INTERCEPTOR(sigsetjmp)
-ASM_TYPE_FUNCTION(ASM_TSAN_SYMBOL_INTERCEPTOR(sigsetjmp))
-ASM_TSAN_SYMBOL_INTERCEPTOR(sigsetjmp):
+.globl ASM_SYMBOL_INTERCEPTOR(sigsetjmp)
+ASM_TYPE_FUNCTION(ASM_SYMBOL_INTERCEPTOR(sigsetjmp))
+ASM_SYMBOL_INTERCEPTOR(sigsetjmp):
 #endif
   CFI_STARTPROC
   // save env parameter
   push %rdi
   CFI_ADJUST_CFA_OFFSET(8)
   CFI_REL_OFFSET(%rdi, 0)
   // save savesigs parameter
   push %rsi
#elif defined(__linux__)
   lea 32(%rsp), %rdi
   mov %rdi, %rsi
   xor %fs:0x30, %rsi  // magic mangling of rsp (see libc setjmp)
   rol $0x11, %rsi
 #else
 # error "Unknown platform"
 #endif
   // call tsan interceptor
-  call ASM_TSAN_SYMBOL(__tsan_setjmp)
+  call ASM_SYMBOL(__tsan_setjmp)
   // unalign stack frame
   add $8, %rsp
   CFI_ADJUST_CFA_OFFSET(-8)
   // restore savesigs parameter
   pop %rsi
   CFI_ADJUST_CFA_OFFSET(-8)
   CFI_RESTORE(%rsi)
   // restore env parameter
   pop %rdi
   CFI_ADJUST_CFA_OFFSET(-8)
   CFI_RESTORE(%rdi)
   // tail jump to libc sigsetjmp
   movl $0, %eax
 #if defined(__NetBSD__)
   movq _ZN14__interception18real___sigsetjmp14E@GOTPCREL(%rip), %rdx
   jmp *(%rdx)
 #elif !defined(__APPLE__)
   movq _ZN14__interception14real_sigsetjmpE@GOTPCREL(%rip), %rdx
   jmp *(%rdx)
 #else
-  jmp ASM_TSAN_SYMBOL(sigsetjmp)
+  jmp ASM_SYMBOL(sigsetjmp)
 #endif
   CFI_ENDPROC
 #if defined(__NetBSD__)
-ASM_SIZE(ASM_TSAN_SYMBOL_INTERCEPTOR(__sigsetjmp14))
+ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(__sigsetjmp14))
 #else
-ASM_SIZE(ASM_TSAN_SYMBOL_INTERCEPTOR(sigsetjmp))
+ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(sigsetjmp))
 #endif
 
 #if !defined(__APPLE__) && !defined(__NetBSD__)
 .comm _ZN14__interception16real___sigsetjmpE,8,8
-.globl ASM_TSAN_SYMBOL_INTERCEPTOR(__sigsetjmp)
-ASM_TYPE_FUNCTION(ASM_TSAN_SYMBOL_INTERCEPTOR(__sigsetjmp))
-ASM_TSAN_SYMBOL_INTERCEPTOR(__sigsetjmp):
+.globl ASM_SYMBOL_INTERCEPTOR(__sigsetjmp)
+ASM_TYPE_FUNCTION(ASM_SYMBOL_INTERCEPTOR(__sigsetjmp))
+ASM_SYMBOL_INTERCEPTOR(__sigsetjmp):
   CFI_STARTPROC
   // save env parameter
   push %rdi
   CFI_ADJUST_CFA_OFFSET(8)
   CFI_REL_OFFSET(%rdi, 0)
   // save savesigs parameter
   push %rsi
   CFI_ADJUST_CFA_OFFSET(8)
   CFI_REL_OFFSET(%rsi, 0)
   // align stack frame
   sub $8, %rsp
   CFI_ADJUST_CFA_OFFSET(8)
   // obtain %rsp
 #if defined(__FreeBSD__)
   lea 24(%rsp), %rdi
   mov %rdi, %rsi
 #else
   lea 32(%rsp), %rdi
   mov %rdi, %rsi
   xor %fs:0x30, %rsi  // magic mangling of rsp (see libc setjmp)
   rol $0x11, %rsi
 #endif
   // call tsan interceptor
-  call ASM_TSAN_SYMBOL(__tsan_setjmp)
+  call ASM_SYMBOL(__tsan_setjmp)
   // unalign stack frame
   add $8, %rsp
   CFI_ADJUST_CFA_OFFSET(-8)
   // restore savesigs parameter
   pop %rsi
   CFI_ADJUST_CFA_OFFSET(-8)
   CFI_RESTORE(%rsi)
   // restore env parameter
   pop %rdi
   CFI_ADJUST_CFA_OFFSET(-8)
   CFI_RESTORE(%rdi)
   // tail jump to libc sigsetjmp
   movl $0, %eax
   movq _ZN14__interception16real___sigsetjmpE@GOTPCREL(%rip), %rdx
   jmp *(%rdx)
   CFI_ENDPROC
-ASM_SIZE(ASM_TSAN_SYMBOL_INTERCEPTOR(__sigsetjmp))
+ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(__sigsetjmp))
 #endif  // !defined(__APPLE__) && !defined(__NetBSD__)
 
 #if defined(__FreeBSD__) || defined(__linux__)
 /* We do not need executable stack.  */
 /* This note is not needed on NetBSD. */
 .section        .note.GNU-stack,"",@progbits
 #endif
 
 #endif

lib/xray/CMakeLists.txt

 
 set(XRAY_COMMON_RUNTIME_OBJECT_LIBS
     RTXray
     RTSanitizerCommon
     RTSanitizerCommonLibc)
 
 if (APPLE)
   set(XRAY_LINK_LIBS ${SANITIZER_COMMON_LINK_LIBS})
-  set(XRAY_ASM_SOURCES xray_trampoline_x86_64.S)
-
-  if (${CMAKE_GENERATOR} STREQUAL "Xcode")
-    enable_language(ASM)
-  else()
-    set_source_files_properties(${XRAY_ASM_SOURCES} PROPERTIES LANGUAGE C)
-  endif()
+  add_asm_sources(XRAY_ASM_SOURCES xray_trampoline_x86_64.S)
 
   add_weak_symbols("sanitizer_common" WEAK_SYMBOL_LINK_FLAGS)
   add_weak_symbols("xray" WEAK_SYMBOL_LINK_FLAGS)
 
   add_compiler_rt_object_libraries(RTXray
     OS ${XRAY_SUPPORTED_OS}
     ARCHS ${XRAY_SUPPORTED_ARCH}
     SOURCES ${x86_64_SOURCES}

lib/xray/xray_trampoline_x86_64.S

#if !defined(__APPLE__)
   .section .text
 #else
   .section __TEXT,__text
 #endif
   .file "xray_trampoline_x86.S"
 
 //===----------------------------------------------------------------------===//
 
-  .globl ASM_TSAN_SYMBOL(__xray_FunctionEntry)
+  .globl ASM_SYMBOL(__xray_FunctionEntry)
   .align 16, 0x90
   ASM_TYPE_FUNCTION(__xray_FunctionEntry)
-ASM_TSAN_SYMBOL(__xray_FunctionEntry):
+ASM_SYMBOL(__xray_FunctionEntry):
   CFI_STARTPROC
   SAVE_REGISTERS
 
   // This load has to be atomic, it's concurrent with __xray_patch().
   // On x86/amd64, a simple (type-aligned) MOV instruction is enough.
-  movq  ASM_TSAN_SYMBOL(_ZN6__xray19XRayPatchedFunctionE)(%rip), %rax
+  movq  ASM_SYMBOL(_ZN6__xray19XRayPatchedFunctionE)(%rip), %rax
   testq %rax, %rax
   je  .Ltmp0
 
   // The patched function prolog puts its xray_instr_map index into %r10d.
   movl  %r10d, %edi
   xor %esi,%esi
   ALIGNED_CALL_RAX
 
 .Ltmp0:
   RESTORE_REGISTERS
   retq
   ASM_SIZE(__xray_FunctionEntry)
   CFI_ENDPROC
 
 //===----------------------------------------------------------------------===//
 
-  .globl ASM_TSAN_SYMBOL(__xray_FunctionExit)
+  .globl ASM_SYMBOL(__xray_FunctionExit)
   .align 16, 0x90
   ASM_TYPE_FUNCTION(__xray_FunctionExit)
-ASM_TSAN_SYMBOL(__xray_FunctionExit):
+ASM_SYMBOL(__xray_FunctionExit):
   CFI_STARTPROC
   // Save the important registers first. Since we're assuming that this
   // function is only jumped into, we only preserve the registers for
   // returning.
   subq  $56, %rsp
   CFI_DEF_CFA_OFFSET(64)
   movq  %rbp, 48(%rsp)
   movupd  %xmm0, 32(%rsp)
   movupd  %xmm1, 16(%rsp)
   movq  %rax, 8(%rsp)
   movq  %rdx, 0(%rsp)
-  movq  ASM_TSAN_SYMBOL(_ZN6__xray19XRayPatchedFunctionE)(%rip), %rax
+  movq  ASM_SYMBOL(_ZN6__xray19XRayPatchedFunctionE)(%rip), %rax
   testq %rax,%rax
   je  .Ltmp2
 
   movl  %r10d, %edi
   movl  $1, %esi
   ALIGNED_CALL_RAX
 
 .Ltmp2:
   // Restore the important registers.
   movq  48(%rsp), %rbp
   movupd  32(%rsp), %xmm0
   movupd  16(%rsp), %xmm1
   movq  8(%rsp), %rax
   movq  0(%rsp), %rdx
   addq  $56, %rsp
   CFI_DEF_CFA_OFFSET(8)
   retq
   ASM_SIZE(__xray_FunctionExit)
   CFI_ENDPROC
 
 //===----------------------------------------------------------------------===//
 
-  .globl ASM_TSAN_SYMBOL(__xray_FunctionTailExit)
+  .globl ASM_SYMBOL(__xray_FunctionTailExit)
   .align 16, 0x90
   ASM_TYPE_FUNCTION(__xray_FunctionTailExit)
-ASM_TSAN_SYMBOL(__xray_FunctionTailExit):
+ASM_SYMBOL(__xray_FunctionTailExit):
   CFI_STARTPROC
   SAVE_REGISTERS
 
-  movq  ASM_TSAN_SYMBOL(_ZN6__xray19XRayPatchedFunctionE)(%rip), %rax
+  movq  ASM_SYMBOL(_ZN6__xray19XRayPatchedFunctionE)(%rip), %rax
   testq %rax,%rax
   je  .Ltmp4
 
   movl  %r10d, %edi
   movl  $2, %esi
 
   ALIGNED_CALL_RAX
 
 .Ltmp4:
   RESTORE_REGISTERS
   retq
   ASM_SIZE(__xray_FunctionTailExit)
   CFI_ENDPROC
 
 //===----------------------------------------------------------------------===//
 
-  .globl ASM_TSAN_SYMBOL(__xray_ArgLoggerEntry)
+  .globl ASM_SYMBOL(__xray_ArgLoggerEntry)
   .align 16, 0x90
   ASM_TYPE_FUNCTION(__xray_ArgLoggerEntry)
-ASM_TSAN_SYMBOL(__xray_ArgLoggerEntry):
+ASM_SYMBOL(__xray_ArgLoggerEntry):
   CFI_STARTPROC
   SAVE_REGISTERS
 
   // Again, these function pointer loads must be atomic; MOV is fine.
-  movq  ASM_TSAN_SYMBOL(_ZN6__xray13XRayArgLoggerE)(%rip), %rax
+  movq  ASM_SYMBOL(_ZN6__xray13XRayArgLoggerE)(%rip), %rax
   testq %rax, %rax
   jne .Larg1entryLog
 
   // If [arg1 logging handler] not set, defer to no-arg logging.
-  movq  ASM_TSAN_SYMBOL(_ZN6__xray19XRayPatchedFunctionE)(%rip), %rax
+  movq  ASM_SYMBOL(_ZN6__xray19XRayPatchedFunctionE)(%rip), %rax
   testq %rax, %rax
   je  .Larg1entryFail
 
 .Larg1entryLog:
 
   // First argument will become the third
   movq  %rdi, %rdx
 
   // XRayEntryType::LOG_ARGS_ENTRY into the second
   mov $0x3, %esi
 
   // 32-bit function ID becomes the first
   movl  %r10d, %edi
   ALIGNED_CALL_RAX
 
 .Larg1entryFail:
   RESTORE_REGISTERS
   retq
   ASM_SIZE(__xray_ArgLoggerEntry)
   CFI_ENDPROC
 
 //===----------------------------------------------------------------------===//
 
-  .global ASM_TSAN_SYMBOL(__xray_CustomEvent)
+  .global ASM_SYMBOL(__xray_CustomEvent)
   .align 16, 0x90
   ASM_TYPE_FUNCTION(__xray_CustomEvent)
-ASM_TSAN_SYMBOL(__xray_CustomEvent):
+ASM_SYMBOL(__xray_CustomEvent):
   CFI_STARTPROC
   SAVE_REGISTERS
 
   // We take two arguments to this trampoline, which should be in rdi and rsi
   // already. We also make sure that we stash %rax because we use that register
   // to call the logging handler.
-  movq ASM_TSAN_SYMBOL(_ZN6__xray22XRayPatchedCustomEventE)(%rip), %rax
+  movq ASM_SYMBOL(_ZN6__xray22XRayPatchedCustomEventE)(%rip), %rax
   testq %rax,%rax
   je .LcustomEventCleanup
 
   ALIGNED_CALL_RAX
 
 .LcustomEventCleanup:
   RESTORE_REGISTERS
   retq
   ASM_SIZE(__xray_CustomEvent)
   CFI_ENDPROC
 
 NO_EXEC_STACK_DIRECTIVE