diff options
| -rw-r--r-- | var/spack/repos/builtin/packages/launchmon/for_aarch64.patch | 1294 | ||||
| -rw-r--r-- | var/spack/repos/builtin/packages/launchmon/package.py | 1 |
2 files changed, 1295 insertions, 0 deletions
diff --git a/var/spack/repos/builtin/packages/launchmon/for_aarch64.patch b/var/spack/repos/builtin/packages/launchmon/for_aarch64.patch new file mode 100644 index 0000000000..43fc853ac4 --- /dev/null +++ b/var/spack/repos/builtin/packages/launchmon/for_aarch64.patch @@ -0,0 +1,1294 @@ +--- spack-src/config.h.in.bak 2016-05-24 12:11:41.000000000 +0900 ++++ spack-src/config.h.in 2020-10-27 16:52:28.052351749 +0900 +@@ -1,5 +1,8 @@ + /* config.h.in. Generated from configure.ac by autoheader. */ + ++/* Define 1 for AARCH64_ARCHITECTURE */ ++#undef AARCH64_ARCHITECTURE ++ + /* Define 1 for AIX_CODE_REQUIRED */ + #undef AIX_CODE_REQUIRED + +@@ -116,6 +119,21 @@ + /* Define to 1 if you have the <string.h> header file. */ + #undef HAVE_STRING_H + ++/* Define to 1 if the system has the type `struct user_fpregs_struct'. */ ++#undef HAVE_STRUCT_USER_FPREGS_STRUCT ++ ++/* Define to 1 if the system has the type `struct user_fpsimd_state'. */ ++#undef HAVE_STRUCT_USER_FPSIMD_STATE ++ ++/* Define to 1 if the system has the type `struct user_fpsimd_struct'. */ ++#undef HAVE_STRUCT_USER_FPSIMD_STRUCT ++ ++/* Define to 1 if the system has the type `struct user_pt_regs'. */ ++#undef HAVE_STRUCT_USER_PT_REGS ++ ++/* Define to 1 if the system has the type `struct user_regs_struct'. */ ++#undef HAVE_STRUCT_USER_REGS_STRUCT ++ + /* Define to 1 if you have the <sys/stat.h> header file. */ + #undef HAVE_SYS_STAT_H + +@@ -158,6 +176,10 @@ + /* install prefix */ + #undef LMON_PREFIX + ++/* Enable use of SGI hostnames as a fallback if no matches in /etc/hosts for ++ the hostname returned by mpiexec.hydra */ ++#undef LMON_SGI_HOSTNAMES ++ + /* Enable a workaround to cope with additional SIGCONT sent by slurmstepd */ + #undef LMON_SLURM_MPAO_WR + +@@ -168,8 +190,7 @@ + slash. */ + #undef LSTAT_FOLLOWS_SLASHED_SYMLINK + +-/* Define to the sub-directory in which libtool stores uninstalled libraries. +- */ ++/* Define to the sub-directory where libtool stores uninstalled libraries. */ + #undef LT_OBJDIR + + /* Define 1 for MEASURE_TRACING_COST */ +@@ -238,6 +259,9 @@ + /* Define 1 for SUB_ARCH_BGQ */ + #undef SUB_ARCH_BGQ + ++/* Define 1 for SUB_ARCH_CRAY */ ++#undef SUB_ARCH_CRAY ++ + /* Define os-isa string */ + #undef TARGET_OS_ISA_STRING + +--- spack-src/configure.bak 2016-05-24 12:24:36.000000000 +0900 ++++ spack-src/configure 2020-10-28 09:31:33.099432617 +0900 +@@ -3526,6 +3526,15 @@ + $as_echo "#define BIT64 1" >>confdefs.h + + ;; ++ *aarch64*) ++$as_echo "#define AARCH64_ARCHITECTURE 1" >>confdefs.h ++ ++ ac_have_known_isa="yes" ++ ac_target_isa="aarch64" ++ ++$as_echo "#define BIT64 1" >>confdefs.h ++ ++ ;; + *i686*) + $as_echo "#define X86_ARCHITECTURE 1" >>confdefs.h + +@@ -18001,6 +18010,57 @@ + + fi + ++ac_fn_c_check_type "$LINENO" "struct user_regs_struct" "ac_cv_type_struct_user_regs_struct" "#include <sys/user.h> ++" ++if test "x$ac_cv_type_struct_user_regs_struct" = xyes; then : ++ ++cat >>confdefs.h <<_ACEOF ++#define HAVE_STRUCT_USER_REGS_STRUCT 1 ++_ACEOF ++ ++ ++fi ++ac_fn_c_check_type "$LINENO" "struct user_pt_regs" "ac_cv_type_struct_user_pt_regs" "#include <sys/user.h> ++" ++if test "x$ac_cv_type_struct_user_pt_regs" = xyes; then : ++ ++cat >>confdefs.h <<_ACEOF ++#define HAVE_STRUCT_USER_PT_REGS 1 ++_ACEOF ++ ++ ++fi ++ac_fn_c_check_type "$LINENO" "struct user_fpregs_struct" "ac_cv_type_struct_user_fpregs_struct" "#include <sys/user.h> ++" ++if test "x$ac_cv_type_struct_user_fpregs_struct" = xyes; then : ++ ++cat >>confdefs.h <<_ACEOF ++#define HAVE_STRUCT_USER_FPREGS_STRUCT 1 ++_ACEOF ++ ++ ++fi ++ac_fn_c_check_type "$LINENO" "struct user_fpsimd_struct" "ac_cv_type_struct_user_fpsimd_struct" "#include <sys/user.h> ++" ++if test "x$ac_cv_type_struct_user_fpsimd_struct" = xyes; then : ++ ++cat >>confdefs.h <<_ACEOF ++#define HAVE_STRUCT_USER_FPSIMD_STRUCT 1 ++_ACEOF ++ ++ ++fi ++ac_fn_c_check_type "$LINENO" "struct user_fpsimd_state" "ac_cv_type_struct_user_fpsimd_state" "#include <sys/user.h> ++" ++if test "x$ac_cv_type_struct_user_fpsimd_state" = xyes; then : ++ ++cat >>confdefs.h <<_ACEOF ++#define HAVE_STRUCT_USER_FPSIMD_STATE 1 ++_ACEOF ++ ++ ++fi ++ + + for ac_header in vfork.h + do : +--- spack-src/launchmon/src/linux/main.cxx.bak 2016-05-24 12:11:41.000000000 +0900 ++++ spack-src/launchmon/src/linux/main.cxx 2020-10-21 10:30:55.761905054 +0900 +@@ -26,6 +26,7 @@ + *-------------------------------------------------------------------------------- + * + * Update Log: ++ * May 02 2018 KMD: Added aarch64 support + * Nov 08 2010 DHA: Added a lexical scope around the driver object + * to support memory tools + * Aug 10 2008 DHA: Now returns EXIT_FAILURE +@@ -44,9 +45,9 @@ + #include "sdbg_base_launchmon.hxx" + #include "sdbg_base_launchmon_impl.hxx" + +-#include "linux/sdbg_linux_mach.hxx" + #include "linux/sdbg_linux_driver.hxx" + #include "linux/sdbg_linux_driver_impl.hxx" ++#include "linux/sdbg_linux_mach.hxx" + + + int main(int argc, char* argv[]) +@@ -56,7 +57,8 @@ + + int rc = EXIT_FAILURE; + { +-#if X86_ARCHITECTURE || X86_64_ARCHITECTURE || PPC_ARCHITECTURE ++#if X86_ARCHITECTURE || X86_64_ARCHITECTURE || PPC_ARCHITECTURE || \ ++ AARCH64_ARCHITECTURE + // + // driver instantiation for the linux platform. + // +--- spack-src/launchmon/src/sdbg_base_mach.hxx.bak 2016-05-24 12:11:41.000000000 +0900 ++++ spack-src/launchmon/src/sdbg_base_mach.hxx 2020-10-20 11:47:56.306294254 +0900 +@@ -26,6 +26,7 @@ + *-------------------------------------------------------------------------------- + * + * Update Log: ++ * May 02 2018 ADG: Added aarch64 support + * Sep 02 2010 DHA: Added MPIR_attach_fifo support + * May 08 2008 DHA: Added an alias (is_master_thread) for get_master_thread + * because the latter isn't entirely intuitive. +@@ -42,16 +43,14 @@ + #include <stack> + #include <string> + +-#include "sdbg_std.hxx" +-#include "sdbg_opt.hxx" + #include "sdbg_base_bp.hxx" +-#include "sdbg_base_symtab.hxx" + #include "sdbg_base_exception.hxx" ++#include "sdbg_base_symtab.hxx" ++#include "sdbg_opt.hxx" ++#include "sdbg_std.hxx" + + const int THREAD_KEY_INVALID = -1; + +- +- + //////////////////////////////////////////////////////////////////////////// + // + // +@@ -82,7 +81,6 @@ + virtual ~machine_exception_t() { } + + }; +- + + //////////////////////////////////////////////////////////////////////////// + // +@@ -131,6 +129,7 @@ + void inc_ptr_by_word () { rs_ptr++; } + void write_word_to_ptr (WT w) { (*rs_ptr) = w; } + unsigned int size_in_word (); ++ size_t size() { return sizeof(NATIVE_RS); } + + protected: + // "rs" retains register set object in its native data structure. +--- spack-src/launchmon/src/linux/sdbg_linux_bp.hxx.bak 2016-05-24 12:11:41.000000000 +0900 ++++ spack-src/launchmon/src/linux/sdbg_linux_bp.hxx 2020-10-21 10:34:38.051897589 +0900 +@@ -26,6 +26,7 @@ + *-------------------------------------------------------------------------------- + * + * Update Log: ++ * May 02 2018 KMD: Added aarch64 support + * Mar 06 2008 DHA: Added indirect breakpoint support + * Mar 11 2008 DHA: Added Linux PowerPC support + * Feb 09 2008 DHA: Added LLNS Copyright +@@ -40,11 +41,11 @@ + #include "sdbg_linux_mach.hxx" + + #if BIT64 +-# if X86_64_ARCHITECTURE ++# if X86_64_ARCHITECTURE || AARCH64_ARCHITECTURE + const int NUM_BYTE_INCR_AFTER_SINGLESTEP = 8; + # else + const int NUM_BYTE_INCR_AFTER_SINGLESTEP = 4; +-# endif //X86_64_ARCHITECTURE ++# endif //X86_64_ARCHITECTURE || AARCH64_ARCHITECTURE + #else + const int NUM_BYTE_INCR_AFTER_SINGLESTEP = 4; + #endif +@@ -53,7 +54,7 @@ + const int NUM_BYTE_INCR_AFTER_TRAP = 1; + #else + const int NUM_BYTE_INCR_AFTER_TRAP = 0; +-#endif ++#endif // X86_64_ARCHITECTURE || AARCH64_ARCHITECTURE + + //! linux_breakpoint_t: + /*! +--- spack-src/launchmon/src/linux/sdbg_linux_driver_impl.hxx.bak 2016-05-24 12:11:41.000000000 +0900 ++++ spack-src/launchmon/src/linux/sdbg_linux_driver_impl.hxx 2020-10-21 10:51:02.851885431 +0900 +@@ -26,6 +26,7 @@ + *-------------------------------------------------------------------------------- + * + * Update Log: ++ * May 02 2018 KMD: Added aarch64 support + * Mar 11 2008 DHA: Added PowerPC support + * Feb 09 2008 DHA: Added LLNS Copyright + * Mar 13 2007 DHA: pipe_t support +@@ -40,9 +41,9 @@ + #include "sdbg_base_driver.hxx" + #include "sdbg_base_driver_impl.hxx" + +-#include "sdbg_linux_mach.hxx" +-#include "sdbg_linux_launchmon.hxx" + #include "sdbg_linux_driver.hxx" ++#include "sdbg_linux_launchmon.hxx" ++#include "sdbg_linux_mach.hxx" + + + //////////////////////////////////////////////////////////////////// +@@ -102,6 +103,8 @@ + return_proc = new linux_ppc_process_t(pid, mi, md, mt, mc); + #elif IA64_ARCHITECTURE + return_proc = new linux_ia64_process_t(pid, mi, md, mt, mc); ++#elif AARCH64_ARCHITECTURE ++ return_proc = new linux_aarch64_process_t(pid, mi, md, mt, mc); + #endif + + return return_proc; +@@ -134,6 +137,8 @@ + return_proc = new linux_ppc_process_t (pid, mi); + #elif IA64_ARCHITECTURE + return_proc = new linux_ia64_process_t (pid, mi); ++#elif AARCH64_ARCHITECTURE ++ return_proc = new linux_aarch64_process_t(pid, mi); + #endif + + return return_proc; +--- spack-src/launchmon/src/linux/sdbg_linux_launchmon.cxx.bak 2016-05-24 12:11:41.000000000 +0900 ++++ spack-src/launchmon/src/linux/sdbg_linux_launchmon.cxx 2020-10-21 10:58:29.611880731 +0900 +@@ -26,6 +26,7 @@ + *-------------------------------------------------------------------------------- + * + * Update Log: ++ * May 02 2018 KMD: Added aarch64 support + * Feb 20 2015 andrewg@cray.com: Added support for RMs that build the + * proctable on demand. Fixed a misplaced brace bug. + * Oct 26 2012 DHA: Removed catch clauses for deprecated thread tracers +@@ -112,34 +113,34 @@ + #endif + + extern "C" { +-#include <sys/types.h> +-#include <sys/stat.h> +-#include <fcntl.h> +-#include <sys/socket.h> + #include <arpa/inet.h> +-#include <link.h> +-#include <thread_db.h> ++#include <fcntl.h> + #include <libgen.h> + #include <limits.h> ++#include <link.h> ++#include <sys/socket.h> ++#include <sys/stat.h> ++#include <sys/types.h> ++#include <thread_db.h> + } + +-#include "sdbg_self_trace.hxx" +-#include "sdbg_base_symtab.hxx" +-#include "sdbg_base_symtab_impl.hxx" + #include "sdbg_base_mach.hxx" + #include "sdbg_base_mach_impl.hxx" ++#include "sdbg_base_symtab.hxx" ++#include "sdbg_base_symtab_impl.hxx" + #include "sdbg_base_tracer.hxx" ++#include "sdbg_self_trace.hxx" + + #include "sdbg_base_launchmon.hxx" + #include "sdbg_base_launchmon_impl.hxx" + #include "sdbg_rm_map.hxx" + +-#include "sdbg_linux_std.hxx" + #include "sdbg_linux_bp.hxx" +-#include "sdbg_linux_mach.hxx" + #include "sdbg_linux_launchmon.hxx" ++#include "sdbg_linux_mach.hxx" + #include "sdbg_linux_ptracer.hxx" + #include "sdbg_linux_ptracer_impl.hxx" ++#include "sdbg_linux_std.hxx" + + #if MEASURE_TRACING_COST + static double accum = 0.0; +@@ -3175,6 +3176,9 @@ + #elif PPC_ARCHITECTURE + thread_base_t<SDBG_LINUX_DFLT_INSTANTIATION> *thrinfo + = new linux_ppc_thread_t(); ++#elif AARCH64_ARCHITECTURE ++ thread_base_t<SDBG_LINUX_DFLT_INSTANTIATION> *thrinfo ++ = new linux_aarch64_thread_t(); + #endif + thrinfo->copy_thread_info(tinfo); + // if the process doesn't contain tid of the given thread, +--- spack-src/launchmon/src/linux/sdbg_linux_mach.cxx.bak 2016-05-24 12:11:41.000000000 +0900 ++++ spack-src/launchmon/src/linux/sdbg_linux_mach.cxx 2020-10-21 11:05:33.491869894 +0900 +@@ -26,6 +26,7 @@ + *-------------------------------------------------------------------------------- + * + * Update Log: ++ * May 02 2018 KMD/ADG: Added aarch64 support + * Sep 02 2010 DHA: Added MPIR_attach_fifo support + * Aug 07 2009 DHA: Added more comments; added exception throwing + * into linux_<arch>_process_t constructors that +@@ -45,9 +46,9 @@ + + #include "sdbg_base_mach.hxx" + #include "sdbg_base_mach_impl.hxx" ++#include "sdbg_linux_mach.hxx" + #include "sdbg_linux_symtab.hxx" + #include "sdbg_linux_symtab_impl.hxx" +-#include "sdbg_linux_mach.hxx" + + + extern "C" { +@@ -1079,4 +1080,397 @@ + return true; + } + +-#endif // ARCHITECTURES ++#elif AARCH64_ARCHITECTURE ++ ++//////////////////////////////////////////////////////////////////// ++// ++// PUBLIC INTERFACES (class linux_aarch64_gpr_set_t) ++// ++// ++ ++//! PUBLIC: linux_aarch64_gpr_set_t ++/*! ++ Default constructor. ++*/ ++linux_aarch64_gpr_set_t::linux_aarch64_gpr_set_t() ++ : MODULENAME(self_trace_t::self_trace().machine_module_trace.module_name) { ++ // This part of the code may be difficult to read. It was trial and error ++ // to detemine what registers are writable and what are not. ++ // Mar 11 2008 DHA ++ // If somebody has ABI documentation that describes all of these, ++ // let me know. ++ // ++ unsigned int gpr_writable_mask = 0; ++ int i; ++ ++ for (i = 0; i <= 30; ++i) { ++ gpr_writable_mask |= (1 << i); ++ } ++ ++ set_user_offset(0); ++ set_writable_mask(gpr_writable_mask); ++ ++} // linux_aarch64_gpr_set_t ++ ++//! PUBLIC: linux_aarch64_gpr_set_t ++/*! ++ get_pc ++*/ ++const T_VA linux_aarch64_gpr_set_t::get_pc() const { ++ T_GRS gpr = get_native_rs(); ++ ++ return gpr.pc; ++} ++ ++//! PUBLIC: linux_aarch64_gpr_set_t ++/*! ++ get_memloc_for_ret_addr ++*/ ++const T_VA linux_aarch64_gpr_set_t::get_ret_addr() const { ++ // ++ // We need to keep track of the "return address" ++ // because that address can result from a single-step ++ // needed for a breakpoint operation. ++ // Essentially, we need to be able to indentify all possible ++ // reasons for a process stop event; otherwise, our ++ // process state transition will cause a BAD thing. ++ // ++ // In the case of Linux AARCH64, according to AARCH64 ABI doc ++ // the Link Register (LR regs[30]) contains that information. ++ // ++ // TODO: This is not always true if the LR is spilled to the ++ // stack to make room for more GP registers. How to determine ++ // this? ++ T_GRS gpr = get_native_rs(); ++ ++ return gpr.regs[30]; ++} ++ ++//! PUBLIC: linux_aarch64_gpr_set_t ++/*! ++ get_memloc_for_ret_addr ++*/ ++const T_VA linux_aarch64_gpr_set_t::get_memloc_for_ret_addr() const { ++ // ++ // We need to keep track of the "return address" ++ // because that address can result from a single-step ++ // needed for a breakpoint operation. ++ // Essentially, we need to be able to indentify all possible ++ // reasons for a process stop event; otherwise, our ++ // process state transition will cause a BAD thing. ++ // ++ // In this architecture, this information is kepted in ++ // the register set. We simply return T_UNINIT_HEX. ++ ++ return T_UNINIT_HEX; ++} ++ ++//! PUBLIC: linux_aarch64_gpr_set_t ++/*! ++ set_pc method doesn't actually write value into tho PC register ++ but into its corresponding data strucuture. The user of this method ++ must ensure writing this back into the register. ++*/ ++void linux_aarch64_gpr_set_t::set_pc(T_VA addr) { rs.pc = addr; } ++ ++//////////////////////////////////////////////////////////////////// ++// ++// PUBLIC INTERFACES (class linux_aarch64_fpr_set_t) ++// ++// ++ ++//! PUBLIC: linux_aarch64_fpr_set_t ++/*! ++ Default constructor. ++*/ ++linux_aarch64_fpr_set_t::linux_aarch64_fpr_set_t() ++ : MODULENAME(self_trace_t::self_trace().machine_module_trace.module_name) { ++ unsigned int fpr_writable_mask = 0xffffffff; ++ set_user_offset(sizeof(T_GRS) + sizeof(int)); ++ set_writable_mask(fpr_writable_mask); ++} ++ ++//////////////////////////////////////////////////////////////////// ++// ++// PUBLIC INTERFACES (class linux_aarch64_thread_t) ++// ++// ++ ++//! PUBLIC: linux_aarch64_thread_t ++/*! ++ Default constructor. ++*/ ++linux_aarch64_thread_t::linux_aarch64_thread_t() ++ : MODULENAME(self_trace_t::self_trace().machine_module_trace.module_name) { ++ set_gprset(new linux_aarch64_gpr_set_t()); ++ set_fprset(new linux_aarch64_fpr_set_t()); ++} ++ ++linux_aarch64_thread_t::~linux_aarch64_thread_t() {} ++ ++//! PUBLIC: linux_aarch64_thread_t ++/*! ++ accessors ++*/ ++pid_t linux_aarch64_thread_t::thr2pid() { ++ // ++ // ti_lid is defined by the pthread debug library. ++ // It contains the lightweight process ID (lwp) that ++ // the kernel can understand. For example, passing this ++ // information into the ptrace system call, the kernel ++ // should operate on the thread. ++ // ++ // thr2pid is a misnomer, it should rather be thr2lwp. ++ // ++ ++ if (is_master_thread()) ++ return (pid_t)get_master_pid(); ++ else ++ return (pid_t)get_thread_info().ti_lid; ++} ++ ++//////////////////////////////////////////////////////////////////// ++// ++// PUBLIC INTERFACES (class linux_aarch64_process_t) ++// ++// ++ ++//! PUBLIC: linux_aarch64_process_t ++/*! ++ Default constructor. ++*/ ++linux_aarch64_process_t::linux_aarch64_process_t() ++ : MODULENAME(self_trace_t::self_trace().machine_module_trace.module_name) {} ++ ++//! PUBLIC: linux_aarch64_process_t ++/*! ++ A constructor. ++*/ ++linux_aarch64_process_t::linux_aarch64_process_t(const std::string& mi, ++ const std::string& md, ++ const std::string& mt, ++ const std::string& mc) { ++ basic_init(mi, md, mt, mc); ++} // linux_aarch64_process_t ++ ++//! PUBLIC: linux_aarch64_process_t ++/*! ++ A constructor. ++*/ ++linux_aarch64_process_t::linux_aarch64_process_t(const pid_t& pid) ++ : MODULENAME(self_trace_t::self_trace().machine_module_trace.module_name) { ++ using namespace std; ++ ++ // ++ // default lwp state is LMON_RM_CREATED ++ // ++ linux_aarch64_thread_t* master_thread = new linux_aarch64_thread_t(); ++ ++ // ++ // indicating this represents the main thread ++ // ++ master_thread->set_master_thread(true); ++ ++ // ++ // pid is lwp pid ++ // ++ master_thread->set_master_pid(pid); ++ ++ // ++ // update the thread list ++ // ++ get_thrlist().insert(make_pair((int)pid, master_thread)); ++ ++ // ++ // TODO: I need to be able to fetch image information ++ // using pid to push it into basic_init. ++ // ++} // linux_aarch64_process_t ++ ++//! PUBLIC: linux_aarch64_process_t ++/*! ++ A constructor: this is the currently recommended constructor ++*/ ++linux_aarch64_process_t::linux_aarch64_process_t(const pid_t& pid, ++ const std::string& mi) ++ : MODULENAME(self_trace_t::self_trace().machine_module_trace.module_name) { ++ using namespace std; ++ ++ // ++ // Once pid is in place, at least the main thread has already ++ // come into existence ++ // ++ ++ // ++ // default lwp state is LMON_RM_CREATED ++ // ++ linux_aarch64_thread_t* master_thread = new linux_aarch64_thread_t(); ++ ++ // ++ // indicating this represents the main thread ++ // ++ master_thread->set_master_thread(true); ++ ++ // ++ // pid is lwp pid ++ // ++ master_thread->set_master_pid(pid); ++ ++ // ++ // update the thread list ++ // ++ get_thrlist().insert(make_pair((int)pid, master_thread)); ++ ++ // ++ // now is the time to initialize my image! ++ // ++ if (!basic_init(mi)) { ++ throw(machine_exception_t("fail to initialize a process")); ++ } ++} // linux_aarch64_process_t ++ ++//! PUBLIC: linux_aarch64_process_t ++/*! ++ A constructor. ++*/ ++linux_aarch64_process_t::linux_aarch64_process_t(const pid_t& pid, ++ const std::string& mi, ++ const std::string& md, ++ const std::string& mt, ++ const std::string& mc) ++ : MODULENAME(self_trace_t::self_trace().machine_module_trace.module_name) { ++ using namespace std; ++ ++ // ++ // Once pid is in place, at least the main thread has already ++ // come into existence ++ // ++ linux_aarch64_thread_t* master_thread = new linux_aarch64_thread_t(); ++ ++ master_thread->set_master_thread(true); ++ ++ master_thread->set_master_pid(pid); ++ ++ get_thrlist().insert(make_pair((int)pid, master_thread)); ++ ++ // ++ // now is the time to initialize my image! ++ // ++ if (!basic_init(mi)) { ++ throw(machine_exception_t("fail to initialize a process")); ++ } ++} // linux_aarch64_process_t ++ ++//! PRIVATE: linux_aarch64_process_t ++/*! ++ launcher_symbols_init ++*/ ++void linux_aarch64_process_t::launcher_symbols_init() { ++ // ++ // symbols relevant to daemon launching ++ // ++ set_launch_breakpoint_sym(LAUNCH_BREAKPOINT); ++ set_launch_being_debug(LAUNCH_BEING_DEBUG); ++ set_launch_debug_state(LAUNCH_DEBUG_STATE); ++ set_launch_debug_gate(LAUNCH_DEBUG_GATE); ++ set_launch_proctable(LAUNCH_PROCTABLE); ++ set_launch_proctable_size(LAUNCH_PROCTABLE_SIZE); ++ set_launch_acquired_premain(LAUNCH_ACQUIRED_PREMAIN); ++ set_launch_exec_path(LAUNCH_EXEC_PATH); ++ set_launch_server_args(LAUNCH_SERVER_ARGS); ++ set_launch_attach_fifo(LAUNCH_ATTACH_FIFO); ++ set_loader_breakpoint_sym(LOADER_BP_SYM); ++ set_loader_r_debug_sym(LOADER_R_DEBUG); ++ set_loader_start_sym(LOADER_START); ++ set_resource_handler_sym(RESOURCE_HANDLER_SYM); ++} ++ ++//! PUBLIC: linux_aarch64_process_t ++/*! ++ basic_init ++*/ ++bool linux_aarch64_process_t::basic_init(const std::string& mi) { ++ struct stat pathchk; ++ ++ // ++ // make sure paths exist ++ // ++ if (stat(mi.c_str(), &pathchk) != 0) { ++ self_trace_t::trace(1, MODULENAME, 1, "Machine: invalid path %s", ++ mi.c_str()); ++ ++ return false; ++ } ++ ++ set_myimage(new linux_image_t<T_VA>(mi)); ++ set_mydynloader_image(new linux_image_t<T_VA>()); ++ set_mythread_lib_image(new linux_image_t<T_VA>()); ++ set_mylibc_image(new linux_image_t<T_VA>()); ++ set_myrmso_image(new linux_image_t<T_VA>()); ++ ++ if (!protected_init(mi)) { ++ self_trace_t::trace(1, MODULENAME, 1, "Machine: protected_init failed."); ++ ++ return false; ++ } ++ ++ launcher_symbols_init(); ++ ++ return true; ++} ++ ++//! PUBLIC: linux_aarch64_process_t ++/*! ++ basic_init ++*/ ++bool linux_aarch64_process_t::basic_init(const std::string& mi, ++ const std::string& md, ++ const std::string& mt, ++ const std::string& mc) { ++ struct stat pathchk; ++ ++ // ++ // make sure paths exist ++ // ++ if (stat(mi.c_str(), &pathchk) != 0) { ++ self_trace_t::trace(1, MODULENAME, 1, "Machine: invalid path %s", ++ mi.c_str()); ++ ++ return false; ++ } ++ if (stat(md.c_str(), &pathchk) != 0) { ++ self_trace_t::trace(1, MODULENAME, 1, "Machine: invalid path %s", ++ md.c_str()); ++ ++ return false; ++ } ++ if (stat(mt.c_str(), &pathchk) != 0) { ++ self_trace_t::trace(1, MODULENAME, 1, "Machine: invalid path %s", ++ mt.c_str()); ++ ++ return false; ++ } ++ if (stat(mc.c_str(), &pathchk) != 0) { ++ self_trace_t::trace(1, MODULENAME, 1, "Machine: invalid path %s", ++ mc.c_str()); ++ ++ return false; ++ } ++ ++ set_myimage(new linux_image_t<T_VA>(mi)); ++ set_mydynloader_image(new linux_image_t<T_VA>(md)); ++ set_mythread_lib_image(new linux_image_t<T_VA>(mt)); ++ set_mylibc_image(new linux_image_t<T_VA>(mc)); ++ ++ if (!protected_init(mi, md, mt, mc)) { ++ self_trace_t::trace(1, MODULENAME, 1, "Machine: protected_init failed."); ++ ++ return false; ++ } ++ ++ launcher_symbols_init(); ++ ++ return true; ++} ++ ++#endif // AARCH64_ARCHITECTURE +--- spack-src/launchmon/src/linux/sdbg_linux_mach.hxx.bak 2016-05-24 12:11:41.000000000 +0900 ++++ spack-src/launchmon/src/linux/sdbg_linux_mach.hxx 2020-10-21 11:13:33.611857965 +0900 +@@ -26,6 +26,7 @@ + *-------------------------------------------------------------------------------- + * + * Update Log: ++ * May 02 2018 KMD: Added aarch64 support + * Mar 06 2009 DHA: Remove dynloader_iden + * Mar 11 2008 DHA: Linux PowerPC support + * Feb 09 2008 DHA: Added LLNS Copyright +@@ -42,10 +43,10 @@ + } + + #include <string> +-#include "sdbg_std.hxx" + #include "sdbg_base_mach.hxx" + #include "sdbg_linux_std.hxx" + #include "sdbg_linux_symtab.hxx" ++#include "sdbg_std.hxx" + + + #if X86_ARCHITECTURE || X86_64_ARCHITECTURE +@@ -372,6 +373,166 @@ + process_base_t<SDBG_LINUX_DFLT_INSTANTIATION>* p; + }; + ++#elif AARCH64_ARCHITECTURE ++ ++//! linux_aarch64_gpr_set_t: ++/*! ++ The class represents linux aarch64 general purpose register set. ++ ++ The offset in the USER area is calculated as following. ++ (This is defined in sys/user.h) ++ ++ === AARCH64 (64 bit process) === ++ ++ struct user_regs_struct ++ { ++ unsigned long long regs[31]; ++ unsigned long long sp; ++ unsigned long long pc; ++ unsigned long long pstate; ++ }; ++ ++ struct user_fpsimd_struct ++ { ++ __uint128_t vregs[32]; ++ unsigned int fpsr; ++ unsigned int fpcr; ++ }; ++ ++ General purpose register set resides at the zero offset. ++*/ ++ ++class linux_aarch64_gpr_set_t : public register_set_base_t<T_GRS, T_VA, T_WT> { ++ public: ++ // constructors and destructor ++ // ++ linux_aarch64_gpr_set_t(); ++ virtual ~linux_aarch64_gpr_set_t() {} ++ ++ virtual void set_pc(T_VA addr); ++ virtual T_VA const get_pc() const; ++ virtual T_VA const get_ret_addr() const; ++ virtual T_VA const get_memloc_for_ret_addr() const; ++ ++ private: ++ bool LEVELCHK(self_trace_verbosity level) { ++ return (self_trace_t::self_trace().tracer_module_trace.verbosity_level >= ++ level); ++ } ++ ++ std::string MODULENAME; ++}; ++ ++//! linux_aarch64_fpr_set_t ++/*! ++ The class represents linux aarch64 general purpose register set. ++ ++ The offset in the USER area is calculated as following. ++ (This is defined in sys/user.h) ++ ++ === AARCH64 (64 bit process) === ++ ++ struct user_regs_struct ++ { ++ unsigned long long regs[31]; ++ unsigned long long sp; ++ unsigned long long pc; ++ unsigned long long pstate; ++ }; ++ ++ struct user_fpsimd_struct ++ { ++ __uint128_t vregs[32]; ++ unsigned int fpsr; ++ unsigned int fpcr; ++ }; ++ ++ General purpose register set resides at the zero offset. ++*/ ++class linux_aarch64_fpr_set_t : public register_set_base_t<T_FRS, T_VA, T_WT> { ++ public: ++ // constructors and destructor ++ // ++ linux_aarch64_fpr_set_t(); ++ virtual ~linux_aarch64_fpr_set_t() {} ++ ++ private: ++ bool LEVELCHK(self_trace_verbosity level) { ++ return (self_trace_t::self_trace().tracer_module_trace.verbosity_level >= ++ level); ++ } ++ ++ std::string MODULENAME; ++}; ++ ++//! class linux_aarch64_thread_t: ++/*! ++ linux_aarch64_thread_t is linux AARCH64 implementation of thread_base_t ++ class. The constructor sets register model. ++*/ ++class linux_aarch64_thread_t ++ : public thread_base_t<SDBG_LINUX_DFLT_INSTANTIATION> { ++ public: ++ // constructors and destructor ++ // ++ linux_aarch64_thread_t(); ++ virtual ~linux_aarch64_thread_t(); ++ ++ // virtual method to convert thread id to lwp ++ // which the kernel understands ++ virtual pid_t thr2pid(); ++ ++ private: ++ bool LEVELCHK(self_trace_verbosity level) { ++ return (self_trace_t::self_trace().tracer_module_trace.verbosity_level >= ++ level); ++ } ++ ++ std::string MODULENAME; ++}; ++ ++//! linux_aarch64_process_t: ++/*! ++ linux_aarch64_process_t is AARCH64 implementation of process_base_t ++ class. The constructor sets register model. ++*/ ++class linux_aarch64_process_t ++ : public process_base_t<SDBG_LINUX_DFLT_INSTANTIATION> { ++ public: ++ // constructors and destructor ++ // ++ linux_aarch64_process_t(); ++ linux_aarch64_process_t(const std::string& mi, const std::string& md, ++ const std::string& mt, const std::string& mc); ++ linux_aarch64_process_t(const pid_t& pid, const std::string& mi, ++ const std::string& md, const std::string& mt, ++ const std::string& mc); ++ linux_aarch64_process_t(const pid_t& pid, const std::string& mi); ++ ++ explicit linux_aarch64_process_t(const pid_t& pid); ++ ~linux_aarch64_process_t() {} ++ ++ protected: ++ bool basic_init(const std::string& mi, const std::string& md, ++ const std::string& mt, const std::string& mc); ++ ++ bool basic_init(const std::string& mi); ++ ++ private: ++ void launcher_symbols_init(); ++ bool LEVELCHK(self_trace_verbosity level) { ++ return (self_trace_t::self_trace().tracer_module_trace.verbosity_level >= ++ level); ++ } ++ ++ std::string MODULENAME; ++}; ++ ++// data structure needed by proc service layer ++// ++struct ps_prochandle { ++ process_base_t<SDBG_LINUX_DFLT_INSTANTIATION>* p; ++}; + + #elif PPC_ARCHITECTURE + +--- spack-src/launchmon/src/linux/sdbg_linux_ptracer_impl.hxx.bak 2016-05-24 12:11:41.000000000 +0900 ++++ spack-src/launchmon/src/linux/sdbg_linux_ptracer_impl.hxx 2020-10-21 11:27:59.251833345 +0900 +@@ -26,6 +26,7 @@ + *-------------------------------------------------------------------------------- + * + * Update Log: ++ * May 02 2018 KMD/ADG: Added aarch64 support + * Mar 06 2008 DHA: Added indirection Breakpoint support. + * insert_breakpoint + * and pullout_breakpoint method. +@@ -51,12 +52,15 @@ + + extern "C" { + +-#include <syscall.h> +-#include <unistd.h> +-#include <sys/types.h> +-#include <sys/ptrace.h> ++#include <elf.h> + #include <errno.h> + #include <signal.h> ++#include <sys/ptrace.h> ++#include <sys/types.h> ++#include <sys/uio.h> ++#include <sys/user.h> ++#include <syscall.h> ++#include <unistd.h> + } + + #include <fstream> +@@ -102,10 +106,6 @@ + { + using namespace std; + +- WT r; +- unsigned int i; +- unsigned int num_regs; +- VA offset; + string e; + string func = "[linux_ptracer_t::tracer_setregs]"; + register_set_base_t<GRS,VA,WT> *regset = p.get_gprset(use_cxt); +@@ -119,8 +119,28 @@ + } + + regset->set_ptr_to_regset(); +- num_regs = regset->size_in_word(); +- offset = regset->get_offset_in_user(); ++ ++#if AARCH64_ARCHITECTURE ++ ++ struct iovec iov; ++ int ret; ++ ++ iov.iov_base = (void*)regset->get_rs_ptr(); ++ iov.iov_len = regset->size(); ++ ++ // Write all general purpose registers in one go ++ ret = Pptrace(PTRACE_SETREGSET, tpid, (void*)NT_PRSTATUS, (void*)&iov); ++ if (ret < 0) { ++ e = func + ERRMSG_PTRACE + strerror(errno); ++ throw linux_tracer_exception_t(e, convert_error_code(errno)); ++ } ++ ++#else ++ ++ WT r; ++ VA offset = regset->get_offset_in_user(); ++ unsigned int num_regs = regset->size_in_word(); ++ unsigned int i; + + for ( i=0; i < num_regs; i++ ) + { +@@ -149,6 +169,8 @@ + offset += sizeof(WT); + } // for ( i=0; i < num_regs; i++ ) + ++#endif ++ + return SDBG_TRACE_OK; + + } // tracer_error_e linux_ptracer_t::tracer_setregs +@@ -168,10 +190,6 @@ + { + using namespace std; + +- WT r; +- unsigned int i; +- unsigned int num_regs; +- VA offset; + string e; + string func = "[linux_ptracer_t::tracer_getregs]"; + register_set_base_t<GRS,VA,WT> *regset = p.get_gprset(use_cxt); +@@ -185,9 +203,29 @@ + } + + regset->set_ptr_to_regset(); +- num_regs = regset->size_in_word(); +- offset = regset->get_offset_in_user(); +- ++ ++#if AARCH64_ARCHITECTURE ++ ++ struct iovec iov; ++ int ret; ++ ++ iov.iov_base = (void*)regset->get_rs_ptr(); ++ iov.iov_len = regset->size(); ++ ++ // Read all general purpose registers in one go ++ ret = Pptrace(PTRACE_GETREGSET, tpid, (void*)NT_PRSTATUS, (void*)&iov); ++ if (ret < 0) { ++ e = func + ERRMSG_PTRACE + strerror(errno); ++ throw linux_tracer_exception_t(e, convert_error_code(errno)); ++ } ++ ++#else ++ ++ WT r; ++ VA offset = regset->get_offset_in_user(); ++ unsigned int num_regs = regset->size_in_word(); ++ unsigned int i; ++ + for ( i=0; i < num_regs; i++ ) + { + +@@ -205,6 +243,8 @@ + + } // for ( i=0; i < num_regs; i++ ) + ++#endif ++ + return SDBG_TRACE_OK; + + } // tracer_error_e linux_ptracer_t::tracer_getfpregs +@@ -223,9 +263,6 @@ + { + using namespace std; + +- WT r; +- int i, num_regs; +- VA offset; + string e; + string func = "[linux_ptracer_t::tracer_getfpregs]"; + register_set_base_t<FRS,VA,WT>* regset = p.get_fprset(use_cxt); +@@ -239,9 +276,29 @@ + } + + regset->set_ptr_to_regset(); +- num_regs = regset->size_in_word(); +- offset = regset->get_offset_in_user(); +- ++ ++#if AARCH64_ARCHITECTURE ++ ++ struct iovec iov; ++ int ret; ++ ++ iov.iov_base = (void*)regset->get_rs_ptr(); ++ iov.iov_len = regset->size(); ++ ++ // Read all floating point registers in one go ++ ret = Pptrace(PTRACE_GETREGSET, tpid, (void*)NT_FPREGSET, (void*)&iov); ++ if (ret < 0) { ++ e = func + ERRMSG_PTRACE + strerror(errno); ++ throw linux_tracer_exception_t(e, convert_error_code(errno)); ++ } ++ ++#else ++ ++ WT r; ++ VA offset = regset->get_offset_in_user(); ++ unsigned int num_regs = regset->size_in_word(); ++ unsigned int i; ++ + for ( i=0; i < num_regs; i++ ) + { + +@@ -258,6 +315,8 @@ + offset += sizeof(WT); + } + ++#endif ++ + return SDBG_TRACE_OK; + + } // tracer_error_e linux_ptracer_t::tracer_getfpregs +--- spack-src/launchmon/src/linux/sdbg_linux_std.hxx.bak 2016-05-24 12:11:41.000000000 +0900 ++++ spack-src/launchmon/src/linux/sdbg_linux_std.hxx 2020-10-27 16:44:38.202365256 +0900 +@@ -26,6 +26,7 @@ + *-------------------------------------------------------------------------------- + * + * Update Log: ++ * May 02 2018 KMD: Added aarch64 support + * Sep 02 2010 DHA: Added MPIR_attach_fifo support + * Dec 16 2009 DHA: Moved backtrace support with C++ demangling here + * Aug 10 2009 DHA: Added more comments +@@ -47,8 +48,8 @@ + #include <stddef.h> + } + +-#include <string> + #include <cxxabi.h> /* picking up demangling service */ ++#include <string> + + //! LAUNCH_BREAKPOINT: + /*! +@@ -230,6 +231,27 @@ + return true; + } + ++// The register and fp register structures are defined differently on ++// various levels of linux. This sets the appropriate struct based on ++// configure checks. ++#if X86_ARCHITECTURE || X86_64_ARCHITECTURE || AARCH64_ARCHITECTURE ++#if defined(HAVE_STRUCT_USER_REGS_STRUCT) ++#define SDBG_LINUX_REGS_STRUCT struct user_regs_struct ++#elif defined(HAVE_STRUCT_USER_PT_REGS) ++#define SDBG_LINUX_REGS_STRUCT struct user_pt_regs ++#else ++#error Missing required definition from <sys/user.h> for cpu registers! ++#endif ++#if defined(HAVE_STRUCT_USER_FPREGS_STRUCT) ++#define SDBG_LINUX_FPREGS_STRUCT struct user_fpregs_struct ++#elif defined(HAVE_STRUCT_USER_FPSIMD_STRUCT) ++#define SDBG_LINUX_FPREGS_STRUCT struct user_fpsimd_struct ++#elif defined(HAVE_STRUCT_USER_FPSIMD_STATE) ++#define SDBG_LINUX_FPREGS_STRUCT struct user_fpsimd_state ++#else ++#error Missing required definition from <sys/user.h> for floating point registers! ++#endif ++#endif + + #if X86_ARCHITECTURE + +@@ -308,6 +330,47 @@ + my_thrinfo_t,\ + elf_wrapper + ++#elif AARCH64_ARCHITECTURE ++ ++// ++// ++// insert linux AARCH64 architecture macros here ... ++// ++// ++// ++ ++#if BIT64 ++// ++// if the target is 64 bit, use the following ++// ++typedef u_int64_t T_VA; ++typedef u_int64_t T_WT; ++typedef u_int32_t T_IT; ++typedef SDBG_LINUX_REGS_STRUCT T_GRS; ++typedef SDBG_LINUX_FPREGS_STRUCT T_FRS; ++const T_IT T_TRAP_INSTRUCTION = 0x00000000d4200000; ++const T_IT T_BLEND_MASK = 0xffffffff00000000; ++const T_IT IT_UNINIT_HEX = 0xdeadbeefdeadbeefULL; ++const T_VA T_UNINIT_HEX = 0xdeadbeefdeadbeef; ++#else ++// 32 bit arm is untested... ++#error 32-bit target is not supported for the ARM architecture ++// ++// if the target is 32 bit, use the following ++// ++typedef u_int32_t T_VA; ++typedef u_int32_t T_WT; ++typedef u_int32_t T_IT; ++typedef SDBG_LINUX_REGS_STRUCT T_GRS; ++typedef SDBG_LINUX_FPREGS_STRUCT T_FRS; ++const T_IT T_TRAP_INSTRUCTION = 0xd4200000; ++const T_IT T_BLEND_MASK = 0x00000000; ++const T_IT IT_UNINIT_HEX = 0xdeadbeef; ++const T_VA T_UNINIT_HEX = 0xdeadbeef; ++#endif // BIT64 ++ ++#define SDBG_LINUX_DFLT_INSTANTIATION \ ++ T_VA, T_WT, T_IT, T_GRS, T_FRS, my_thrinfo_t, elf_wrapper + + #elif PPC_ARCHITECTURE + +--- spack-src/launchmon/src/linux/sdbg_proc_service.cxx.bak 2016-05-24 12:11:41.000000000 +0900 ++++ spack-src/launchmon/src/linux/sdbg_proc_service.cxx 2020-10-21 11:38:27.761815829 +0900 +@@ -26,6 +26,7 @@ + *-------------------------------------------------------------------------------- + * + * Update Log: ++ * May 02 2018 KMD: Added aarch64 support + * Mar 11 2008 DHA: Added PowerPC support + * Feb 09 2008 DHA: Added LLNS Copyright + * Jul 18 2006 DHA: Initial Linux PPC (BG/L) port +@@ -47,14 +48,13 @@ + #error This source file requires a LINUX OS + #endif + +- +-#include "sdbg_proc_service.hxx" +-#include "sdbg_linux_std.hxx" +-#include "sdbg_linux_ptracer.hxx" +-#include "sdbg_linux_ptracer_impl.hxx" + #include "sdbg_base_mach.hxx" + #include "sdbg_base_mach_impl.hxx" + #include "sdbg_linux_mach.hxx" ++#include "sdbg_linux_ptracer.hxx" ++#include "sdbg_linux_ptracer_impl.hxx" ++#include "sdbg_linux_std.hxx" ++#include "sdbg_proc_service.hxx" + + extern "C" { + #include <libgen.h> +@@ -81,7 +81,7 @@ + unsigned int empty:25; + }; + +-#elif X86_64_ARCHITECTURE ++#elif X86_64_ARCHITECTURE || AARCH64_ARCHITECTURE + + #ifndef PTRACE_ARCH_PRCTL + #define PTRACE_ARCH_PRCTL 30 /* arch_prctl for child */ +@@ -347,7 +347,7 @@ + + *addr = (psaddr_t) (tsd_desc.base_addr); + +-#elif X86_64_ARCHITECTURE ++#elif X86_64_ARCHITECTURE || AARCH64_ARCHITECTURE + /* + * How to fetch thread-specific area for x86-64/linux + * diff --git a/var/spack/repos/builtin/packages/launchmon/package.py b/var/spack/repos/builtin/packages/launchmon/package.py index 4b80687a27..3115e63b55 100644 --- a/var/spack/repos/builtin/packages/launchmon/package.py +++ b/var/spack/repos/builtin/packages/launchmon/package.py @@ -27,6 +27,7 @@ class Launchmon(AutotoolsPackage): depends_on("spectrum-mpi", when='arch=ppc64le') patch('launchmon-char-conv.patch', when='@1.0.2') + patch('for_aarch64.patch', when='@:1.0.2 target=aarch64:') def setup_build_environment(self, env): if self.spec.satisfies('@master'): |