summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--var/spack/repos/builtin/packages/launchmon/for_aarch64.patch1294
-rw-r--r--var/spack/repos/builtin/packages/launchmon/package.py1
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'):