[lldb] Add FixAnyAddress to ABI plugins

[DavidSpickett]

Summary

FixAnyAddress is to be used when we don't know or don't care
whether we're fixing a code or data address.

By using FixAnyAddress over the others, you document that no
specific choice was made.

On all existing platforms apart from Arm Thumb, you could use
either FixCodeAddress or FixDataAddress and be fine. Up until
now I've chosen to use FixDataAddress but if I had
chosen to use FixCodeAddress that would have broken Arm Thumb.

Hence FixAnyAddress, to give you the "safest" option when you're
in generic code.

Uses of FixDataAddress in memory region code have been changed
to FixAnyAddress. The functionality is unchanged.

[DavidSpickett]

This comes from https://reviews.llvm.org/D118794 on the subject of whether it's ok to just pick one of fixcode/fixdata and assume it'll work.

Of all the uses of Fix, my own memory region changes are the only ones so far that fit FixAnyAddress. The rest look appropriate. I plan to use it in https://reviews.llvm.org/D118794 instead of FixDataAddress.

@JDevlieghere You did some work around this area in https://reviews.llvm.org/D100521 so can you tell me if this makes sense to add in general? There were some comments there:

This looks good. Jonas, what do you think about having FixDataAddress() methods in the ABI's. We're going to be quickly sprinkling FixCodeAddress calls throughout lldb at places where Linux/Darwin ABI need them, and it'd be nice if we have the FixDataAddress method available (even if they're identical right now) so someone doesn't need to audit all the calls in the future and adjust them as appropriate.

FixAnyAddress aims to do the same thing but for when we don't know what we have.

[omjavaid]

Looks good to me.

[JDevlieghere]

Yes, this makes a lot of sense to me. Thanks for taking care of this. LGTM.

lldb/include/lldb/Target/ABI.h

public:
   /// Some targets might use bits in a code address to indicate a mode switch.
   /// ARM uses bit zero to signify a code address is thumb, so any ARM ABI
   /// plug-ins would strip those bits.
   /// @{
   virtual lldb::addr_t FixCodeAddress(lldb::addr_t pc) { return pc; }
   virtual lldb::addr_t FixDataAddress(lldb::addr_t pc) { return pc; }
   /// @}
 
+  /// Use this method when you do not know, or do not care what kind of address
+  /// you are fixing. On platforms where there would be a difference between the
+  /// two types, it will pick the safest option.
+  ///
+  /// Its purpose is to signal that no specific choice was made and provide an
+  /// alternative to randomly picking FixCode/FixData address. Which could break
+  /// platforms where there is a difference (only Arm Thumb at this time).
+  virtual lldb::addr_t FixAnyAddress(lldb::addr_t pc) {
+    // On Arm Thumb fixing a code address zeroes the bottom bit, so FixData is
+    // the safe choice. On any other platform (so far) code and data addresses
+    // are fixed in the same way.
+    return FixDataAddress(pc);
+  }
+
   llvm::MCRegisterInfo &GetMCRegisterInfo() { return *m_mc_register_info_up; }
 
   virtual void
   AugmentRegisterInfo(std::vector<DynamicRegisterInfo::Register> &regs) = 0;
 
   virtual bool GetPointerReturnRegister(const char *&name) { return false; }
 
   static lldb::ABISP FindPlugin(lldb::ProcessSP process_sp, const ArchSpec &arch);

lldb/source/Commands/CommandObjectMemory.cpp

if (argc == 1) {
                // When we're repeating the command, the previous end address is
                // used for load_addr. If that was 0xF...F then we must have
                // reached the end of memory.
                (argc == 0 && load_addr == LLDB_INVALID_ADDRESS) ||
                // If the target has non-address bits (tags, limited virtual
                // address size, etc.), the end of mappable memory will be lower
                // than that. So if we find any non-address bit set, we must be
                // at the end of the mappable range.
-               (abi && (abi->FixDataAddress(load_addr) != load_addr))) {
+               (abi && (abi->FixAnyAddress(load_addr) != load_addr))) {
       result.AppendErrorWithFormat("'%s' takes one argument:\nUsage: %s\n",
                                    m_cmd_name.c_str(), m_cmd_syntax.c_str());
       return false;
     }
 
     lldb_private::MemoryRegionInfo range_info;
     error = process_sp->GetMemoryRegionInfo(load_addr, range_info);
     if (error.Success()) {

lldb/source/Target/Process.cpp

Process::AdvanceAddressToNextBranchInstruction(Address default_stop_addr,
   }
 
   return retval;
 }
 
 Status Process::GetMemoryRegionInfo(lldb::addr_t load_addr,
                                     MemoryRegionInfo &range_info) {
   if (const lldb::ABISP &abi = GetABI())
-    load_addr = abi->FixDataAddress(load_addr);
+    load_addr = abi->FixAnyAddress(load_addr);
   return DoGetMemoryRegionInfo(load_addr, range_info);
 }
 
 Status Process::GetMemoryRegions(lldb_private::MemoryRegionInfos &region_list) {
   Status error;
 
   lldb::addr_t range_end = 0;
   const lldb::ABISP &abi = GetABI();
if (region_info.GetMapped() == MemoryRegionInfo::eYes) {
       region_list.push_back(std::move(region_info));
     }
   } while (
       // For a process with no non-address bits, all address bits
       // set means the end of memory.
       range_end != LLDB_INVALID_ADDRESS &&
       // If we have non-address bits and some are set then the end
       // is at or beyond the end of mappable memory.
-      !(abi && (abi->FixDataAddress(range_end) != range_end)));
+      !(abi && (abi->FixAnyAddress(range_end) != range_end)));
 
   return error;
 }
 
 Status
 Process::ConfigureStructuredData(ConstString type_name,
                                  const StructuredData::ObjectSP &config_sp) {
   // If you get this, the Process-derived class needs to implement a method to