Use the `addressing_bits` kv in the stop packet from the remote stub, if present

[jasonmolenda]

Summary

On an AArch64 system using pointer authentication, where lldb needs to disregard signing in the top bits, lldb needs to know how many bits are used for addressing (and therefore are significant). This is normally a fixed value, and can be communicated in the qHostInfo packet's addressing_bits kv pair.

On a firmware debug session with early startup code that is setting up the page tables, the value will change during the lifetime of the process. To support this correctly, the remote stub (a JTAG type debugger) can specify the current number of addressing bits in every stop packet, or include it in the stop packet when the value has changed. It's a bit of a specialized environment where this is needed -- for all user process debugging, the value will not change during the lifetime of the process.

This patch has lldb read the value from the stop packet and set the Process addressing masks if it is present.

[bulbazord]

Makes sense to me!

lldb/docs/lldb-gdb-remote.txt

 //                                  threads in the "threads" list.
 //                                  lldb may request that this be included in the T
 //                                  packet via the QListThreadsInStopReply packet
 //                                  earlier in the debug session.
 //
 //                                  Example:
 //                                  thread-pcs:dec14,2cf872b0,2cf8681c,2d02d68c,2cf716a8;
 //
+//  "addressing_bits" unsigned optional  Specifies how many bits in addresses 
+//                                       are significant for addressing, base 
+//                                       10.  If bits 38..0 in a 64-bit 
+//                                       pointer are significant for 
+//                                       addressing, then the value is 39.  
+//                                       This is needed on e.g. AArch64
+//                                       v8.3 ABIs that use pointer 
+//                                       authentication in the high bits.
+//                                       This value is normally sent in the
+//                                       qHostInfo packet response, and if the
+//                                       value cannot change during the process
+//                                       lifetime, it does not need to be 
+//                                       duplicated here in the stop packet.
+//                                       For a firmware environment with early
+//                                       start code that may be changing the
+//                                       page table setup, a dynamically set
+//                                       value may be needed.
+//
 // BEST PRACTICES:
 //  Since register values can be supplied with this packet, it is often useful
 //  to return the PC, SP, FP, LR (if any), and FLAGS registers so that separate
 //  packets don't need to be sent to read each of these registers from each
 //  thread.
 //
 //  If a thread is stopped for no reason (like just because another thread
 //  stopped, or because when one core stops all cores should stop), use a

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

while (stop_packet.GetNameColonValue(key, value)) {
           LLDB_LOG(log, "Invalid PID/TID to fork: {0}", value);
           pid_tid = {{LLDB_INVALID_PROCESS_ID, LLDB_INVALID_THREAD_ID}};
         }
 
         reason = key.str();
         StreamString ostr;
         ostr.Printf("%" PRIu64 " %" PRIu64, pid_tid->first, pid_tid->second);
         description = std::string(ostr.GetString());
+      } else if (key.compare("addressing_bits") == 0) {
+        uint64_t addressing_bits;
+        if (!value.getAsInteger(0, addressing_bits)) {
+          addr_t address_mask = ~((1ULL << addressing_bits) - 1);
+          SetCodeAddressMask(address_mask);
+          SetDataAddressMask(address_mask);
+        }
       } else if (key.size() == 2 && ::isxdigit(key[0]) && ::isxdigit(key[1])) {
         uint32_t reg = UINT32_MAX;
         if (!key.getAsInteger(16, reg))
           expedited_register_map[reg] = std::string(std::move(value));
       }
     }
 
     if (stop_pid != LLDB_INVALID_PROCESS_ID && stop_pid != pid) {