Revert "[XRay] Add support for instrumentation of DSOs on x86_64 (#90959)"

This reverts commit a440203 and 4451f9f

Author: metaflow

clang/include/clang/Basic/CodeGenOptions.def

@@ -136,8 +136,6 @@ CODEGENOPT(XRayIgnoreLoops , 1, 0)
 ///< Emit the XRay function index section.
 CODEGENOPT(XRayFunctionIndex , 1, 1)
 
-///< Set when -fxray-shared is enabled
-CODEGENOPT(XRayShared , 1, 0)
 
 ///< Set the minimum number of instructions in a function to determine selective
 ///< XRay instrumentation.

clang/include/clang/Driver/Options.td

@@ -2946,11 +2946,6 @@ def fxray_selected_function_group :
   HelpText<"When using -fxray-function-groups, select which group of functions to instrument. Valid range is 0 to fxray-function-groups - 1">,
   MarshallingInfoInt<CodeGenOpts<"XRaySelectedFunctionGroup">, "0">;
 
-defm xray_shared : BoolFOption<"xray-shared",
-  CodeGenOpts<"XRayShared">, DefaultFalse,
-  PosFlag<SetTrue, [], [ClangOption, CC1Option],
-          "Enable shared library instrumentation with XRay">,
-  NegFlag<SetFalse>>;
 
 defm fine_grained_bitfield_accesses : BoolOption<"f", "fine-grained-bitfield-accesses",
   CodeGenOpts<"FineGrainedBitfieldAccesses">, DefaultFalse,

clang/include/clang/Driver/XRayArgs.h

@@ -27,7 +27,6 @@ class XRayArgs {
   XRayInstrSet InstrumentationBundle;
   llvm::opt::Arg *XRayInstrument = nullptr;
   bool XRayRT = true;
-  bool XRayShared = false;
 
 public:
   /// Parses the XRay arguments from an argument list.
@@ -36,7 +35,6 @@ class XRayArgs {
                llvm::opt::ArgStringList &CmdArgs, types::ID InputType) const;
 
   bool needsXRayRt() const { return XRayInstrument && XRayRT; }
-  bool needsXRayDSORt() const { return XRayInstrument && XRayRT && XRayShared; }
   llvm::ArrayRef<std::string> modeList() const { return Modes; }
   XRayInstrSet instrumentationBundle() const { return InstrumentationBundle; }
 };

clang/lib/Driver/ToolChains/CommonArgs.cpp

@@ -1613,14 +1613,10 @@ bool tools::addSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
 }
 
 bool tools::addXRayRuntime(const ToolChain&TC, const ArgList &Args, ArgStringList &CmdArgs) {
-  if (Args.hasArg(options::OPT_shared)) {
-    if (TC.getXRayArgs().needsXRayDSORt()) {
-      CmdArgs.push_back("--whole-archive");
-      CmdArgs.push_back(TC.getCompilerRTArgString(Args, "xray-dso"));
-      CmdArgs.push_back("--no-whole-archive");
-      return true;
-    }
-  } else if (TC.getXRayArgs().needsXRayRt()) {
+  if (Args.hasArg(options::OPT_shared))
+    return false;
+
+  if (TC.getXRayArgs().needsXRayRt()) {
     CmdArgs.push_back("--whole-archive");
     CmdArgs.push_back(TC.getCompilerRTArgString(Args, "xray"));
     for (const auto &Mode : TC.getXRayArgs().modeList())

clang/lib/Driver/XRayArgs.cpp

@@ -63,23 +63,6 @@ XRayArgs::XRayArgs(const ToolChain &TC, const ArgList &Args) {
         << XRayInstrument->getSpelling() << Triple.str();
   }
 
-  if (Args.hasFlag(options::OPT_fxray_shared, options::OPT_fno_xray_shared,
-                   false)) {
-    XRayShared = true;
-
-    // DSO instrumentation is currently limited to x86_64
-    if (Triple.getArch() != llvm::Triple::x86_64) {
-      D.Diag(diag::err_drv_unsupported_opt_for_target)
-          << "-fxray-shared" << Triple.str();
-    }
-
-    unsigned PICLvl = std::get<1>(tools::ParsePICArgs(TC, Args));
-    if (!PICLvl) {
-      D.Diag(diag::err_opt_not_valid_without_opt) << "-fxray-shared"
-                                                  << "-fPIC";
-    }
-  }
-
   // Both XRay and -fpatchable-function-entry use
   // TargetOpcode::PATCHABLE_FUNCTION_ENTER.
   if (Arg *A = Args.getLastArg(options::OPT_fpatchable_function_entry_EQ))
@@ -194,10 +177,6 @@ void XRayArgs::addArgs(const ToolChain &TC, const ArgList &Args,
   Args.addOptOutFlag(CmdArgs, options::OPT_fxray_function_index,
                      options::OPT_fno_xray_function_index);
 
-  if (XRayShared)
-    Args.addOptInFlag(CmdArgs, options::OPT_fxray_shared,
-                      options::OPT_fno_xray_shared);
-
   if (const Arg *A =
           Args.getLastArg(options::OPT_fxray_instruction_threshold_EQ)) {
     int Value;

clang/test/Driver/XRay/xray-shared.cpp

@@ -104,7 +104,6 @@ else()
 set(ALL_XRAY_SUPPORTED_ARCH ${X86_64} ${ARM32} ${ARM64} ${MIPS32} ${MIPS64}
 		powerpc64le ${HEXAGON} ${LOONGARCH64})
 endif()
-set(ALL_XRAY_DSO_SUPPORTED_ARCH ${X86_64})
 set(ALL_SHADOWCALLSTACK_SUPPORTED_ARCH ${ARM64})
 
 if (UNIX)

compiler-rt/cmake/Modules/AllSupportedArchDefs.cmake

@@ -668,9 +668,6 @@ if(APPLE)
   list_intersect(XRAY_SUPPORTED_ARCH
     ALL_XRAY_SUPPORTED_ARCH
     SANITIZER_COMMON_SUPPORTED_ARCH)
-  list_intersect(XRAY_DSO_SUPPORTED_ARCH
-    ALL_XRAY_DSO_SUPPORTED_ARCH
-    SANITIZER_COMMON_SUPPORTED_ARCH)
   list_intersect(SHADOWCALLSTACK_SUPPORTED_ARCH
     ALL_SHADOWCALLSTACK_SUPPORTED_ARCH
     SANITIZER_COMMON_SUPPORTED_ARCH)
@@ -705,7 +702,6 @@ else()
   filter_available_targets(CFI_SUPPORTED_ARCH ${ALL_CFI_SUPPORTED_ARCH})
   filter_available_targets(SCUDO_STANDALONE_SUPPORTED_ARCH ${ALL_SCUDO_STANDALONE_SUPPORTED_ARCH})
   filter_available_targets(XRAY_SUPPORTED_ARCH ${ALL_XRAY_SUPPORTED_ARCH})
-  filter_available_targets(XRAY_DSO_SUPPORTED_ARCH ${ALL_XRAY_DSO_SUPPORTED_ARCH})
   filter_available_targets(SHADOWCALLSTACK_SUPPORTED_ARCH
     ${ALL_SHADOWCALLSTACK_SUPPORTED_ARCH})
   filter_available_targets(GWP_ASAN_SUPPORTED_ARCH ${ALL_GWP_ASAN_SUPPORTED_ARCH})

compiler-rt/cmake/config-ix.cmake

@@ -93,78 +93,31 @@ enum XRayPatchingStatus {
   FAILED = 3,
 };
 
-/// This tells XRay to patch the instrumentation points in all currently loaded
-/// objects. See XRayPatchingStatus for possible result values.
+/// This tells XRay to patch the instrumentation points. See XRayPatchingStatus
+/// for possible result values.
 extern XRayPatchingStatus __xray_patch();
 
-/// This tells XRay to patch the instrumentation points in the given object.
-/// See XRayPatchingStatus for possible result values.
-extern XRayPatchingStatus __xray_patch_object(int32_t ObjId);
-
 /// Reverses the effect of __xray_patch(). See XRayPatchingStatus for possible
 /// result values.
 extern XRayPatchingStatus __xray_unpatch();
 
-/// Reverses the effect of __xray_patch_object. See XRayPatchingStatus for
-/// possible result values.
-extern XRayPatchingStatus __xray_unpatch_object(int32_t ObjId);
-
-/// This unpacks the given (packed) function id and patches
-/// the corresponding function.  See XRayPatchingStatus for possible
+/// This patches a specific function id. See XRayPatchingStatus for possible
 /// result values.
 extern XRayPatchingStatus __xray_patch_function(int32_t FuncId);
 
-/// This patches a specific function in the given object. See XRayPatchingStatus
-/// for possible result values.
-extern XRayPatchingStatus __xray_patch_function_in_object(int32_t FuncId,
-                                                          int32_t ObjId);
-
-/// This unpacks the given (packed) function id and unpatches
-/// the corresponding function. See XRayPatchingStatus for possible
+/// This unpatches a specific function id. See XRayPatchingStatus for possible
 /// result values.
 extern XRayPatchingStatus __xray_unpatch_function(int32_t FuncId);
 
-/// This unpatches a specific function in the given object.
-/// See XRayPatchingStatus for possible result values.
-extern XRayPatchingStatus __xray_unpatch_function_in_object(int32_t FuncId,
-                                                            int32_t ObjId);
-
-/// This function unpacks the given (packed) function id and returns the address
-/// of the corresponding function. We return 0 if we encounter any error, even
-/// if 0 may be a valid function address.
+/// This function returns the address of the function provided a valid function
+/// id. We return 0 if we encounter any error, even if 0 may be a valid function
+/// address.
 extern uintptr_t __xray_function_address(int32_t FuncId);
 
-/// This function returns the address of the function in the given object
-/// provided valid function and object ids. We return 0 if we encounter any
-/// error, even if 0 may be a valid function address.
-extern uintptr_t __xray_function_address_in_object(int32_t FuncId,
-                                                   int32_t ObjId);
-
-/// This function returns the maximum valid function id for the main executable
-/// (object id = 0). Returns 0 if we encounter errors (when there are no
-/// instrumented functions, etc.).
+/// This function returns the maximum valid function id. Returns 0 if we
+/// encounter errors (when there are no instrumented functions, etc.).
 extern size_t __xray_max_function_id();
 
-/// This function returns the maximum valid function id for the given object.
-/// Returns 0 if we encounter errors (when there are no instrumented functions,
-/// etc.).
-extern size_t __xray_max_function_id_in_object(int32_t ObjId);
-
-/// This function returns the number of previously registered objects
-/// (executable + loaded DSOs). Returns 0 if XRay has not been initialized.
-extern size_t __xray_num_objects();
-
-/// Unpacks the function id from the given packed id.
-extern int32_t __xray_unpack_function_id(int32_t PackedId);
-
-/// Unpacks the object id from the given packed id.
-extern int32_t __xray_unpack_object_id(int32_t PackedId);
-
-/// Creates and returns a packed id from the given function and object ids.
-/// If the ids do not fit within the reserved number of bits for each part, the
-/// high bits are truncated.
-extern int32_t __xray_pack_id(int32_t FuncId, int32_t ObjId);
-
 /// Initialize the required XRay data structures. This is useful in cases where
 /// users want to control precisely when the XRay instrumentation data
 /// structures are initialized, for example when the XRay library is built with

compiler-rt/include/xray/xray_interface.h

@@ -10,10 +10,6 @@ set(XRAY_SOURCES
   xray_utils.cpp
   )
 
-set(XRAY_DSO_SOURCES
-  xray_dso_init.cpp
-  )
-
 # Implementation files for all XRay modes.
 set(XRAY_FDR_MODE_SOURCES
   xray_fdr_flags.cpp
@@ -37,11 +33,6 @@ set(x86_64_SOURCES
   xray_trampoline_x86_64.S
   )
 
-set(x86_64_DSO_SOURCES
-   xray_trampoline_x86_64.S
-   )
-
-
 set(arm_SOURCES
   xray_arm.cpp
   xray_trampoline_arm.S
@@ -137,12 +128,10 @@ set(XRAY_IMPL_HEADERS
 # consumption by tests.
 set(XRAY_ALL_SOURCE_FILES
   ${XRAY_SOURCES}
-  ${XRAY_DSO_SOURCES}
   ${XRAY_FDR_MODE_SOURCES}
   ${XRAY_BASIC_MODE_SOURCES}
   ${XRAY_PROFILING_MODE_SOURCES}
   ${x86_64_SOURCES}
-  ${x86_64_DSO_SOURCES}
   ${arm_SOURCES}
   ${armhf_SOURCES}
   ${hexagon_SOURCES}
@@ -173,9 +162,6 @@ set(XRAY_CFLAGS
   ${COMPILER_RT_CXX_CFLAGS})
 set(XRAY_COMMON_DEFINITIONS SANITIZER_COMMON_NO_REDEFINE_BUILTINS XRAY_HAS_EXCEPTIONS=1)
 
-# DSO trampolines need to be compiled with GOT addressing
-set(XRAY_COMMON_DEFINITIONS_DSO ${XRAY_COMMON_DEFINITIONS} XRAY_PIC)
-
 # Too many existing bugs, needs cleanup.
 append_list_if(COMPILER_RT_HAS_WNO_FORMAT -Wno-format XRAY_CFLAGS)
 
@@ -215,16 +201,7 @@ if (APPLE)
     CFLAGS ${XRAY_CFLAGS}
     DEFS ${XRAY_COMMON_DEFINITIONS}
     DEPS ${XRAY_DEPS})
-  add_compiler_rt_object_libraries(RTXrayDSO
-    OS ${XRAY_SUPPORTED_OS}
-    ARCHS ${XRAY_DSO_SUPPORTED_ARCH}
-    SOURCES ${XRAY_DSO_SOURCES}
-    ADDITIONAL_HEADERS ${XRAY_IMPL_HEADERS}
-    CFLAGS ${XRAY_CFLAGS}
-    DEFS ${XRAY_COMMON_DEFINITIONS_DSO}
-    DEPS ${XRAY_DEPS})
   set(XRAY_RTXRAY_ARCH_LIBS "")
-  set(XRAY_DSO_RTXRAY_ARCH_LIBS "")
   foreach(arch ${XRAY_SUPPORTED_ARCH})
     if(NOT ${arch} IN_LIST XRAY_SOURCE_ARCHS)
       continue()
@@ -238,17 +215,6 @@ if (APPLE)
       DEFS ${XRAY_COMMON_DEFINITIONS}
       DEPS ${XRAY_DEPS})
     list(APPEND XRAY_RTXRAY_ARCH_LIBS RTXray_${arch})
-    if (${arch} IN_LIST XRAY_DSO_SUPPORTED_ARCH)
-      add_compiler_rt_object_libraries(RTXrayDSO_${arch}
-        OS ${XRAY_SUPPORTED_OS}
-        ARCHS ${XRAY_DSO_SUPPORTED_ARCH}
-        SOURCES ${${arch}_DSO_SOURCES}
-        ADDITIONAL_HEADERS ${XRAY_IMPL_HEADERS}
-        CFLAGS ${XRAY_CFLAGS}
-        DEFS ${XRAY_COMMON_DEFINITIONS_DSO}
-        DEPS ${XRAY_DEPS})
-      list(APPEND XRAY_DSO_RTXRAY_ARCH_LIBS RTXrayDSO_${arch})
-    endif()
   endforeach()
   add_compiler_rt_object_libraries(RTXrayFDR
     OS ${XRAY_SUPPORTED_OS}
@@ -286,17 +252,6 @@ if (APPLE)
     LINK_FLAGS ${XRAY_LINK_FLAGS} ${WEAK_SYMBOL_LINK_FLAGS}
     LINK_LIBS ${XRAY_LINK_LIBS}
     PARENT_TARGET xray)
-  add_compiler_rt_runtime(clang_rt.xray-dso
-    STATIC
-    OS ${XRAY_SUPPORTED_OS}
-    ARCHS ${XRAY_DSO_SUPPORTED_ARCH}
-    OBJECT_LIBS RTXrayDSO ${XRAY_DSO_RTXRAY_ARCH_LIBS}
-    CFLAGS ${XRAY_CFLAGS}
-    DEFS ${XRAY_COMMON_DEFINITIONS}
-    LINK_FLAGS ${XRAY_LINK_FLAGS} ${WEAK_SYMBOL_LINK_FLAGS}
-    LINK_LIBS ${XRAY_LINK_LIBS}
-    PARENT_TARGET xray)
-
   add_compiler_rt_runtime(clang_rt.xray-fdr
     STATIC
     OS ${XRAY_SUPPORTED_OS}
@@ -391,37 +346,16 @@ else() # not Apple
       DEFS ${XRAY_COMMON_DEFINITIONS}
       OBJECT_LIBS RTXrayBASIC
       PARENT_TARGET xray)
-    # Profiler Mode runtime
-    add_compiler_rt_runtime(clang_rt.xray-profiling
-      STATIC
-      ARCHS ${arch}
-      CFLAGS ${XRAY_CFLAGS}
-      LINK_FLAGS ${XRAY_LINK_FLAGS}
-      LINK_LIBS ${XRAY_LINK_LIBS}
-      DEFS ${XRAY_COMMON_DEFINITIONS}
-      OBJECT_LIBS RTXrayPROFILING
-      PARENT_TARGET xray)
-
-    if (${arch} IN_LIST XRAY_DSO_SUPPORTED_ARCH)
-      # TODO: Only implemented for X86 at the moment
-      add_compiler_rt_object_libraries(RTXrayDSO
-        ARCHS ${arch}
-        SOURCES ${XRAY_DSO_SOURCES} ${${arch}_DSO_SOURCES} 
-        ADDITIONAL_HEADERS ${XRAY_IMPL_HEADERS}
-        CFLAGS ${XRAY_CFLAGS}
-        DEFS ${XRAY_COMMON_DEFINITIONS_DSO}
-        DEPS ${XRAY_DEPS})
-      # DSO runtime archive
-      add_compiler_rt_runtime(clang_rt.xray-dso
-        STATIC
-        ARCHS ${arch}
-        CFLAGS ${XRAY_CFLAGS}
-        LINK_FLAGS ${XRAY_LINK_FLAGS}
-        LINK_LIBS ${XRAY_LINK_LIBS}
-        DEFS ${XRAY_COMMON_DEFINITIONS}
-        OBJECT_LIBS RTXrayDSO
-        PARENT_TARGET xray)
-    endif()
+   # Profiler Mode runtime
+   add_compiler_rt_runtime(clang_rt.xray-profiling
+     STATIC
+     ARCHS ${arch}
+     CFLAGS ${XRAY_CFLAGS}
+     LINK_FLAGS ${XRAY_LINK_FLAGS}
+     LINK_LIBS ${XRAY_LINK_LIBS}
+     DEFS ${XRAY_COMMON_DEFINITIONS}
+     OBJECT_LIBS RTXrayPROFILING
+     PARENT_TARGET xray)
   endforeach()
 endif() # not Apple