WIP: Lane divergence support

gdb/amdgpu-tdep.c

@@ -1607,7 +1607,7 @@ amdgpu_address_spaces (struct gdbarch *gdbarch)
 }
 
 static location_scope
-amdgpu_address_scope (struct gdbarch *gdbarch, CORE_ADDR address)
+amdgpu_address_scope (struct gdbarch *gdbarch, ptid_t ptid, CORE_ADDR address)
 {
   amd_dbgapi_segment_address_dependency_t segment_address_dependency;
 
@@ -1630,10 +1630,28 @@ amdgpu_address_scope (struct gdbarch *gdbarch, CORE_ADDR address)
       != AMD_DBGAPI_STATUS_SUCCESS)
     error (_("amd_dbgapi_dwarf_address_space_to_address_space failed"));
 
-  if (amd_dbgapi_address_dependency (address_space_id,
-				     segment_address,
-				     &segment_address_dependency)
-      != AMD_DBGAPI_STATUS_SUCCESS)
+  amd_dbgapi_status_t ret;
+#if AMD_DBGAPI_VERSION_MAJOR > 0 || AMD_DBGAPI_VERSION_MINOR >= 79
+  /* Access to GPU globals can be made from host threads.  When we place a
+     watchpoint on such global GPU variable, a matching watchpoint is also
+     added on the CPU side for the same address, so it is possible to call here
+     with a ptid that belongs to a non-GPU thread.  */
+  const amd_dbgapi_wave_id_t wave_id = (ptid_is_gpu (ptid)
+					? get_amd_dbgapi_wave_id (ptid)
+					: AMD_DBGAPI_WAVE_NONE);
+
+  amd_dbgapi_process_id_t process_id
+    = get_amd_dbgapi_process_id (current_inferior ());
+
+  ret = amd_dbgapi_address_dependency (process_id, wave_id,
+				       address_space_id, segment_address,
+				       &segment_address_dependency);
+#else
+  ret = amd_dbgapi_address_dependency (address_space_id,
+				       segment_address,
+				       &segment_address_dependency);
+#endif
+  if (ret != AMD_DBGAPI_STATUS_SUCCESS)
     error (_("amd_dbgapi_address_dependency failed"));
 
   switch (segment_address_dependency)

gdb/arch-utils.c

@@ -1165,7 +1165,7 @@ default_dwarf_address_space_to_address_space_id (LONGEST dwarf_addr_space)
 
 /* See arch-utils.h.  */
 location_scope
-default_address_scope (struct gdbarch *gdbarch, CORE_ADDR address)
+default_address_scope (struct gdbarch *gdbarch, ptid_t ptid, CORE_ADDR address)
 {
   return LOCATION_SCOPE_INFERIOR;
 }

gdb/arch-utils.h

@@ -357,7 +357,7 @@ extern CORE_ADDR default_segment_address_to_core_address
 
 /* Return the address's scope.  */
 extern location_scope default_address_scope (struct gdbarch *gdbarch,
-					     CORE_ADDR address);
+					     ptid_t ptid, CORE_ADDR address);
 
 extern int default_supported_lanes_count (struct gdbarch *gdbarch,
 					  thread_info *tp);

gdb/blockframe.c

@@ -111,10 +111,10 @@ get_pc_function_start (CORE_ADDR pc)
   return 0;
 }
 
-/* Return the symbol for the function executing in frame FRAME.  */
+/* Return the block for the function executing in frame FRAME.  */
 
-struct symbol *
-get_frame_function (const frame_info_ptr &frame)
+const struct block *
+get_frame_function_block (const frame_info_ptr &frame)
 {
   const struct block *bl = get_frame_block (frame, 0);
 
@@ -124,7 +124,18 @@ get_frame_function (const frame_info_ptr &frame)
   while (bl->function () == NULL && bl->superblock () != NULL)
     bl = bl->superblock ();
 
-  return bl->function ();
+  return bl;
+}
+
+/* Return the symbol for the function executing in frame FRAME.  */
+
+struct symbol *
+get_frame_function (const frame_info_ptr &frame)
+{
+  const block *bl = get_frame_function_block (frame);
+  if (bl != nullptr)
+    return bl->function ();
+  return nullptr;
 }
 
 

gdb/breakpoint.c

@@ -5732,6 +5732,13 @@ bpstat_check_breakpoint_conditions (bpstat *bs, thread_info *thread)
   /* Remember the SIMD mask.  */
   bs->simd_lane_mask = thread->active_simd_lanes_mask ();
 
+  /* If the breakpoint is set for a specific lane, mask all other
+     lanes.  */
+  if (b->thread != -1
+      && b->thread == thread->global_num
+      && b->lane >= 0)
+    bs->simd_lane_mask &= (simd_lanes_mask_t) 1 << b->lane;
+
   /* If we hit the breakpoint with all lanes inactive, don't stop.
      This can happen in conditional/divergent code -- the compiler may
      decide it's cheaper to execute a block of instructions unmasked
@@ -6850,7 +6857,11 @@ print_one_breakpoint_location (struct breakpoint *b,
 	{
 	  struct thread_info *thr = find_thread_global_id (b->thread);
 
-	  uiout->field_string ("thread", print_thread_id (thr));
+	  if (b->lane >= 0)
+	    uiout->field_fmt ("thread", "%s, lane %d",
+			      print_thread_id (thr), b->lane);
+	  else
+	    uiout->field_string ("thread", print_thread_id (thr));
 	}
       uiout->text ("\n");
     }
@@ -7375,10 +7386,15 @@ describe_other_breakpoints (struct gdbarch *gdbarch,
 	    else if (b.thread != -1)
 	      {
 		struct thread_info *thr = find_thread_global_id (b.thread);
-		gdb_printf (" (thread %s)", print_thread_id (thr));
+		gdb_printf (" (thread %s", print_thread_id (thr));
+		if (b.lane >= 0)
+		  gdb_printf (", lane %d)", b.lane);
+		else
+		  gdb_printf (")");
 	      }
 	    else if (b.task != -1)
 	      gdb_printf (" (task %d)", b.task);
+
 	    gdb_printf ("%s%s ",
 			((b.enable_state == bp_disabled
 			  || b.enable_state == bp_call_disabled)
@@ -10646,7 +10662,8 @@ watch_command_1 (const char *arg, int accessflag, int from_tty,
       value_free_to_mark (mark);
 
       CORE_ADDR addr = value_as_address (val.get ());
-      scope = gdbarch_address_scope (val->type ()->arch (), addr);
+      scope = gdbarch_address_scope (val->type ()->arch (), inferior_ptid,
+				     addr);
 
       if (use_mask)
 	{
@@ -10670,7 +10687,7 @@ watch_command_1 (const char *arg, int accessflag, int from_tty,
 	     and so it needs to be reconfirmed now.  */
 	  if (iter->lval () == lval_memory)
 	    scope |= gdbarch_address_scope (iter->type ()->arch (),
-					    iter->address ());
+					    inferior_ptid, iter->address ());
 	  scope |= iter->scope ();
 	}
 

gdb/breakpoint.h

@@ -863,6 +863,10 @@ struct breakpoint : public intrusive_list_node<breakpoint>
      care.  */
   int thread = -1;
 
+  /* Lane number for thread specific breakpoint, or -1 if don't care.
+     It is taken into consideration iff THREAD is specified.  */
+  int lane = -1;
+
   /* Inferior number for inferior-specific breakpoint, or -1 if this
      breakpoint is for all inferiors.  */
   int inferior = -1;

gdb/buildsym.h

@@ -106,6 +106,10 @@ struct context_stack
 
     struct dynamic_prop *static_link;
 
+    /* Expression that computes the lane pc of the lexically enclosing
+       function, if any.  NULL otherwise.  */
+    dynamic_prop *lane_pc = nullptr;
+
     /* PC where this context starts */
 
     CORE_ADDR start_addr;

gdb/c-lang.c

@@ -39,6 +39,7 @@
 #include "gdbarch.h"
 #include "c-exp.h"
 #include "arch-utils.h"
+#include "inferior.h"
 
 /* Given a C string type, STR_TYPE, return the corresponding target
    character set name.  */
@@ -708,7 +709,8 @@ value *aspace_operation::evaluate (struct type *expect_type,
     lookup_pointer_type (builtin_type (exp->gdbarch)->builtin_void);
 
   val = value_from_pointer (generic_ptr_type, adddress);
-  val->set_scope (gdbarch_address_scope (exp->gdbarch, adddress));
+  val->set_scope (gdbarch_address_scope (exp->gdbarch, inferior_ptid,
+					 adddress));
   return val;
 }
 

gdb/compile/compile.c

@@ -561,10 +561,10 @@ show_compile_gcc (struct ui_file *file, int from_tty,
    put into DW_AT_producer - see GCC function gen_producer_string.  */
 
 static const char *
-get_selected_pc_producer_options (void)
+get_selected_frame_producer_options (void)
 {
-  CORE_ADDR pc = get_frame_pc (get_selected_frame (NULL));
-  struct compunit_symtab *symtab = find_pc_compunit_symtab (pc);
+  compunit_symtab *symtab
+    = get_frame_compunit_symtab (get_selected_frame (NULL));
   const char *cs;
 
   if (symtab == NULL || symtab->producer () == NULL
@@ -632,7 +632,7 @@ get_args (const compile_instance *compiler, struct gdbarch *gdbarch)
   if (!gcc_options.empty ())
     result = gdb_argv (gcc_options.c_str ());
 
-  cs_producer_options = get_selected_pc_producer_options ();
+  cs_producer_options = get_selected_frame_producer_options ();
   if (cs_producer_options != NULL)
     {
       gdb_argv argv_producer (cs_producer_options);