Remove special Hexagon packet traversal code

[ted]

Summary

On Hexagon, breakpoints need to be on the first instruction of a packet.
When the LLVM disassembler for Hexagon returned 32 bit instructions, we
needed code to find the start of the current packet. Now that the LLVM
disassembler for Hexagon returns packets instead of instructions, we always
have the first instruction of the packet. Remove the packet traversal code
because it can cause problems when the next packet has more than one
instruction.

[clayborg]

LGTM after fixing clang format related changes seen in "Lint: Pre-merge checks"

[ted]

Fixed formatting flagged by Lint: Pre-merge checks

lldb/include/lldb/Core/Disassembler.h

public:
   /// Get the index of the next branch instruction.
   ///
   /// Given a list of instructions, find the next branch instruction
   /// in the list by returning an index.
   ///
   /// @param[in] start
   ///     The instruction index of the first instruction to check.
   ///
-  /// @param[in] target
-  ///     A LLDB target object that is used to resolve addresses.
-  ///    
   /// @param[in] ignore_calls
   ///     It true, then fine the first branch instruction that isn't
   ///     a function call (a branch that calls and returns to the next
   ///     instruction). If false, find the instruction index of any 
   ///     branch in the list.
   ///     
   /// @param[out] found_calls
   ///     If non-null, this will be set to true if any calls were found in 
   ///     extending the range.
   ///    
   /// @return
   ///     The instruction index of the first branch that is at or past
   ///     \a start. Returns UINT32_MAX if no matching branches are 
   ///     found.
   //------------------------------------------------------------------
   uint32_t GetIndexOfNextBranchInstruction(uint32_t start,
-                                           Target &target,
                                            bool ignore_calls,
                                            bool *found_calls) const;
 
   uint32_t GetIndexOfInstructionAtLoadAddress(lldb::addr_t load_addr,
                                               Target &target);
 
   uint32_t GetIndexOfInstructionAtAddress(const Address &addr);
 

lldb/source/Core/Disassembler.cpp

 
 void InstructionList::Append(lldb::InstructionSP &inst_sp) {
   if (inst_sp)
     m_instructions.push_back(inst_sp);
 }
 
 uint32_t
 InstructionList::GetIndexOfNextBranchInstruction(uint32_t start,
-                                                 Target &target,
                                                  bool ignore_calls,
                                                  bool *found_calls) const {
   size_t num_instructions = m_instructions.size();
 
   uint32_t next_branch = UINT32_MAX;
-  size_t i;
   
   if (found_calls)
     *found_calls = false;
-  for (i = start; i < num_instructions; i++) {
+  for (size_t i = start; i < num_instructions; i++) {
     if (m_instructions[i]->DoesBranch()) {
       if (ignore_calls && m_instructions[i]->IsCall()) {
         if (found_calls)
           *found_calls = true;
         continue;
       }
       next_branch = i;
       break;
     }
   }
 
-  // Hexagon needs the first instruction of the packet with the branch. Go
-  // backwards until we find an instruction marked end-of-packet, or until we
-  // hit start.
-  if (target.GetArchitecture().GetTriple().getArch() == llvm::Triple::hexagon) {
-    // If we didn't find a branch, find the last packet start.
-    if (next_branch == UINT32_MAX) {
-      i = num_instructions - 1;
-    }
-
-    while (i > start) {
-      --i;
-
-      Status error;
-      uint32_t inst_bytes;
-      bool prefer_file_cache = false; // Read from process if process is running
-      lldb::addr_t load_addr = LLDB_INVALID_ADDRESS;
-      target.ReadMemory(m_instructions[i]->GetAddress(), prefer_file_cache,
-                        &inst_bytes, sizeof(inst_bytes), error, &load_addr);
-      // If we have an error reading memory, return start
-      if (!error.Success())
-        return start;
-      // check if this is the last instruction in a packet bits 15:14 will be
-      // 11b or 00b for a duplex
-      if (((inst_bytes & 0xC000) == 0xC000) ||
-          ((inst_bytes & 0xC000) == 0x0000)) {
-        // instruction after this should be the start of next packet
-        next_branch = i + 1;
-        break;
-      }
-    }
-
-    if (next_branch == UINT32_MAX) {
-      // We couldn't find the previous packet, so return start
-      next_branch = start;
-    }
-  }
   return next_branch;
 }
 
 uint32_t
 InstructionList::GetIndexOfInstructionAtAddress(const Address &address) {
   size_t num_instructions = m_instructions.size();
   uint32_t index = UINT32_MAX;
   for (size_t i = 0; i < num_instructions; i++) {

lldb/source/Target/Process.cpp

Process::AdvanceAddressToNextBranchInstruction(Address default_stop_addr,
   }
 
   size_t insn_offset =
       insn_list->GetIndexOfInstructionAtAddress(default_stop_addr);
   if (insn_offset == UINT32_MAX) {
     return retval;
   }
 
-  uint32_t branch_index =
-      insn_list->GetIndexOfNextBranchInstruction(insn_offset, target,
-                                                 false /* ignore_calls*/,
-                                                 nullptr);
+  uint32_t branch_index = insn_list->GetIndexOfNextBranchInstruction(
+      insn_offset, false /* ignore_calls*/, nullptr);
   if (branch_index == UINT32_MAX) {
     return retval;
   }
 
   if (branch_index > insn_offset) {
     Address next_branch_insn_address =
         insn_list->GetInstructionAtIndex(branch_index)->GetAddress();
     if (next_branch_insn_address.IsValid() &&

lldb/source/Target/ThreadPlanStepRange.cpp

bool ThreadPlanStepRange::SetNextBranchBreakpoint() {
   // if we haven't already:
   size_t pc_index;
   size_t range_index;
   InstructionList *instructions =
       GetInstructionsForAddress(cur_addr, range_index, pc_index);
   if (instructions == nullptr)
     return false;
   else {
-    Target &target = GetThread().GetProcess()->GetTarget();
     const bool ignore_calls = GetKind() == eKindStepOverRange;
-    uint32_t branch_index =
-        instructions->GetIndexOfNextBranchInstruction(pc_index, target,
-                                                      ignore_calls, 
-                                                      &m_found_calls);
-
+    uint32_t branch_index = instructions->GetIndexOfNextBranchInstruction(
+        pc_index, ignore_calls, &m_found_calls);
     Address run_to_address;
 
     // If we didn't find a branch, run to the end of the range.
     if (branch_index == UINT32_MAX) {
       uint32_t last_index = instructions->GetSize() - 1;
       if (last_index - pc_index > 1) {
         InstructionSP last_inst =
             instructions->GetInstructionAtIndex(last_index);