[xray] Use hidden symbol visibility for xray trampolines

[ianlevesque]

Summary

We load multiple copies of the trampolines into memory when instrumenting DSOs. Hidden visibility prevents conflicts in this scenario.

[dberris]

LGTM for the x86_64 bits.

[MaskRay]

I haven't studied these tranpolines yet but it is correct to use hidden visibility on ELF (no-op on Mach-O). This can avoid PLT entries for shared objects.

compiler-rt/lib/xray/xray_trampoline_AArch64.S

 #include "../builtins/assembly.h"
 
     .text
     /* The variable containing the handler function pointer */
     .global _ZN6__xray19XRayPatchedFunctionE
     /* Word-aligned function entry point */
     .p2align 2
     /* Let C/C++ see the symbol */
     .global __xray_FunctionEntry
+    .hidden __xray_FunctionEntry
     .type __xray_FunctionEntry, %function
     /* In C++ it is void extern "C" __xray_FunctionEntry(uint32_t FuncId) with
          FuncId passed in W0 register. */
 __xray_FunctionEntry:
     /* Move the return address beyond the end of sled data. The 12 bytes of
          data are inserted in the code of the runtime patch, between the call
          instruction and the instruction returned into. The data contains 32
          bits of instrumented function ID and 64 bits of the address of
FunctionEntry_restore:
     LDP X3, X4, [SP], #16
     LDP X1, X2, [SP], #16
     RET
 
     /* Word-aligned function entry point */
     .p2align 2
     /* Let C/C++ see the symbol */
     .global __xray_FunctionExit
+    .hidden __xray_FunctionExit
     .type __xray_FunctionExit, %function
     /* In C++ it is void extern "C" __xray_FunctionExit(uint32_t FuncId) with
          FuncId passed in W0 register. */
 __xray_FunctionExit:
     /* Move the return address beyond the end of sled data. The 12 bytes of
          data are inserted in the code of the runtime patch, between the call
          instruction and the instruction returned into. The data contains 32
          bits of instrumented function ID and 64 bits of the address of
FunctionExit_restore:
     LDP X3, X4, [SP], #16
     LDP X1, X2, [SP], #16
     RET
 
     /* Word-aligned function entry point */
     .p2align 2
     /* Let C/C++ see the symbol */
     .global __xray_FunctionTailExit
+    .hidden __xray_FunctionTailExit
     .type __xray_FunctionTailExit, %function
     /* In C++ it is void extern "C" __xray_FunctionTailExit(uint32_t FuncId)
          with FuncId passed in W0 register. */
 __xray_FunctionTailExit:
     /* Move the return address beyond the end of sled data. The 12 bytes of
          data are inserted in the code of the runtime patch, between the call
          instruction and the instruction returned into. The data contains 32
          bits of instrumented function ID and 64 bits of the address of

compiler-rt/lib/xray/xray_trampoline_arm.S

 #include "../builtins/assembly.h"
 
     .syntax unified
     .arch armv6t2
     .fpu vfpv2
     .code 32
     .global _ZN6__xray19XRayPatchedFunctionE
 
     @ Word-aligned function entry point
     .p2align 2
     @ Let C/C++ see the symbol
     .global __xray_FunctionEntry
+    .hidden __xray_FunctionEntry
     @ It preserves all registers except r0, r12(ip), r14(lr) and r15(pc)
     @ Assume that "q" part of the floating-point registers is not used
     @   for passing parameters to C/C++ functions.
     .type __xray_FunctionEntry, %function
     @ In C++ it is void extern "C" __xray_FunctionEntry(uint32_t FuncId) with
     @   FuncId passed in r0 register.
 __xray_FunctionEntry:
     PUSH {r1-r3,lr}
FunctionEntry_restore:
     @ Restore floating-point parameters of the instrumented function
     VPOP {d0-d7}
     POP {r1-r3,pc}
 
     @ Word-aligned function entry point
     .p2align 2
     @ Let C/C++ see the symbol
   .global __xray_FunctionExit
+  .hidden __xray_FunctionExit
   @ Assume that d1-d7 are not used for the return value.
     @ Assume that "q" part of the floating-point registers is not used for the
     @   return value in C/C++.
   .type __xray_FunctionExit, %function
   @ In C++ it is extern "C" void __xray_FunctionExit(uint32_t FuncId) with
     @   FuncId passed in r0 register.
 __xray_FunctionExit:
     PUSH {r1-r3,lr}
FunctionExit_restore:
     @ Restore the floating-point return value of the instrumented function
     VPOP {d0}
     POP {r1-r3,pc}
 
     @ Word-aligned function entry point
     .p2align 2
     @ Let C/C++ see the symbol
     .global __xray_FunctionTailExit
+    .hidden __xray_FunctionTailExit
     @ It preserves all registers except r0, r12(ip), r14(lr) and r15(pc)
     @ Assume that "q" part of the floating-point registers is not used
     @   for passing parameters to C/C++ functions.
     .type __xray_FunctionTailExit, %function
     @ In C++ it is void extern "C" __xray_FunctionTailExit(uint32_t FuncId)
     @   with FuncId passed in r0 register.
 __xray_FunctionTailExit:
     PUSH {r1-r3,lr}

compiler-rt/lib/xray/xray_trampoline_x86_64.S

#if !defined(__APPLE__)
   .file "xray_trampoline_x86.S"
 #else
   .section __TEXT,__text
 #endif
 
 //===----------------------------------------------------------------------===//
 
   .globl ASM_SYMBOL(__xray_FunctionEntry)
+  ASM_HIDDEN(__xray_FunctionEntry)
   .align 16, 0x90
   ASM_TYPE_FUNCTION(__xray_FunctionEntry)
 # LLVM-MCA-BEGIN __xray_FunctionEntry
 ASM_SYMBOL(__xray_FunctionEntry):
   CFI_STARTPROC
   SAVE_REGISTERS
 
   // This load has to be atomic, it's concurrent with __xray_patch().
.Ltmp0:
   retq
 # LLVM-MCA-END
   ASM_SIZE(__xray_FunctionEntry)
   CFI_ENDPROC
 
 //===----------------------------------------------------------------------===//
 
   .globl ASM_SYMBOL(__xray_FunctionExit)
+  ASM_HIDDEN(__xray_FunctionExit)
   .align 16, 0x90
   ASM_TYPE_FUNCTION(__xray_FunctionExit)
 # LLVM-MCA-BEGIN __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.
.Ltmp2:
   retq
 # LLVM-MCA-END
   ASM_SIZE(__xray_FunctionExit)
   CFI_ENDPROC
 
 //===----------------------------------------------------------------------===//
 
   .globl ASM_SYMBOL(__xray_FunctionTailExit)
+  ASM_HIDDEN(__xray_FunctionTailExit)
   .align 16, 0x90
   ASM_TYPE_FUNCTION(__xray_FunctionTailExit)
 # LLVM-MCA-BEGIN __xray_FunctionTailExit
 ASM_SYMBOL(__xray_FunctionTailExit):
   CFI_STARTPROC
   SAVE_REGISTERS
 
   movq  ASM_SYMBOL(_ZN6__xray19XRayPatchedFunctionE)(%rip), %rax
.Ltmp4:
   retq
 # LLVM-MCA-END
   ASM_SIZE(__xray_FunctionTailExit)
   CFI_ENDPROC
 
 //===----------------------------------------------------------------------===//
 
   .globl ASM_SYMBOL(__xray_ArgLoggerEntry)
+  ASM_HIDDEN(__xray_ArgLoggerEntry)
   .align 16, 0x90
   ASM_TYPE_FUNCTION(__xray_ArgLoggerEntry)
 # LLVM-MCA-BEGIN __xray_ArgLoggerEntry
 ASM_SYMBOL(__xray_ArgLoggerEntry):
   CFI_STARTPROC
   SAVE_REGISTERS
 
   // Again, these function pointer loads must be atomic; MOV is fine.
.Larg1entryFail:
   retq
 # LLVM-MCA-END
   ASM_SIZE(__xray_ArgLoggerEntry)
   CFI_ENDPROC
 
 //===----------------------------------------------------------------------===//
 
   .global ASM_SYMBOL(__xray_CustomEvent)
+  ASM_HIDDEN(__xray_CustomEvent)
   .align 16, 0x90
   ASM_TYPE_FUNCTION(__xray_CustomEvent)
 # LLVM-MCA-BEGIN __xray_CustomEvent
 ASM_SYMBOL(__xray_CustomEvent):
   CFI_STARTPROC
   SAVE_REGISTERS
 
   // We take two arguments to this trampoline, which should be in rdi and rsi
.LcustomEventCleanup:
   retq
 # LLVM-MCA-END
   ASM_SIZE(__xray_CustomEvent)
   CFI_ENDPROC
 
 //===----------------------------------------------------------------------===//
 
   .global ASM_SYMBOL(__xray_TypedEvent)
+  ASM_HIDDEN(__xray_TypedEvent)
   .align 16, 0x90
   ASM_TYPE_FUNCTION(__xray_TypedEvent)
 # LLVM-MCA-BEGIN __xray_TypedEvent
 ASM_SYMBOL(__xray_TypedEvent):
   CFI_STARTPROC
   SAVE_REGISTERS
 
   // We pass three arguments to this trampoline, which should be in rdi, rsi