[trace][intelpt] fix some test failures

[wallace]

Summary

Minor fixes needed and now ./bin/lldb-dotest -p TestTrace passes
correctly.

• There was an incorrect iteration.
• Some error messages changed.
• The way repeat commands are handled changed a bit, so I had to create

a new --continue arg in "thread trace dump instructions" to handle this
correctly.

[wallace]

nit

[jj10306]

lgtm

lldb/source/Commands/CommandObjectThread.cpp

CommandObjectTraceExport(CommandInterpreter &interpreter)
       : CommandObjectMultiword(
             interpreter, "trace thread export",
             "Commands for exporting traces of the threads in the current "
             "process to different formats.",
             "thread trace export <export-plugin> [<subcommand objects>]") {
 
     unsigned i = 0;
     for (llvm::StringRef plugin_name =
-             PluginManager::GetTraceExporterPluginNameAtIndex(i++);
+             PluginManager::GetTraceExporterPluginNameAtIndex(i);
          !plugin_name.empty();
          plugin_name = PluginManager::GetTraceExporterPluginNameAtIndex(i++)) {
       if (ThreadTraceExportCommandCreator command_creator =
               PluginManager::GetThreadTraceExportCommandCreatorAtIndex(i)) {
         LoadSubCommand(plugin_name, command_creator(interpreter));
       }
     }
   }
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
       case 'f': {
         m_forwards = true;
         break;
       }
       case 't': {
         m_show_tsc = true;
         break;
       }
+      case 'C': {
+        m_continue = true;
+        break;
+      }
       default:
         llvm_unreachable("Unimplemented option");
       }
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_count = kDefaultCount;
       m_skip = 0;
       m_raw = false;
       m_forwards = false;
       m_show_tsc = false;
+      m_continue = false;
     }
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_thread_trace_dump_instructions_options);
     }
 
     static const size_t kDefaultCount = 20;
 
     // Instance variables to hold the values for command options.
     size_t m_count;
     size_t m_skip;
     bool m_raw;
     bool m_forwards;
     bool m_show_tsc;
+    bool m_continue;
   };
 
   CommandObjectTraceDumpInstructions(CommandInterpreter &interpreter)
       : CommandObjectIterateOverThreads(
             interpreter, "thread trace dump instructions",
             "Dump the traced instructions for one or more threads. If no "
             "threads are specified, show the current thread.  Use the "
             "thread-index \"all\" to see all threads.",
             nullptr,
             eCommandRequiresProcess | eCommandTryTargetAPILock |
                 eCommandProcessMustBeLaunched | eCommandProcessMustBePaused |
                 eCommandProcessMustBeTraced) {}
 
   ~CommandObjectTraceDumpInstructions() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
   llvm::Optional<std::string> GetRepeatCommand(Args &current_command_args,
                                                uint32_t index) override {
-    current_command_args.GetCommandString(m_repeat_command);
-    m_create_repeat_command_just_invoked = true;
-    return m_repeat_command;
+    std::string cmd;
+    current_command_args.GetCommandString(cmd);
+    if (cmd.find("--continue") == std::string::npos)
+      cmd += " --continue";
+    return cmd;
   }
 
 protected:
   bool DoExecute(Args &args, CommandReturnObject &result) override {
-    if (!IsRepeatCommand())
+    if (!m_options.m_continue)
       m_dumpers.clear();
 
-    bool status = CommandObjectIterateOverThreads::DoExecute(args, result);
-
-    m_create_repeat_command_just_invoked = false;
-    return status;
-  }
-
-  bool IsRepeatCommand() {
-    return !m_repeat_command.empty() && !m_create_repeat_command_just_invoked;
+    return CommandObjectIterateOverThreads::DoExecute(args, result);
   }
 
   bool HandleOneThread(lldb::tid_t tid, CommandReturnObject &result) override {
     Stream &s = result.GetOutputStream();
 
     const TraceSP &trace_sp = m_exe_ctx.GetTargetSP()->GetTrace();
     ThreadSP thread_sp =
         m_exe_ctx.GetProcessPtr()->GetThreadList().FindThreadByID(tid);
if (!m_dumpers.count(thread_sp->GetID())) {
       m_dumpers[thread_sp->GetID()] = std::move(dumper);
     }
 
     m_dumpers[thread_sp->GetID()]->DumpInstructions(s, m_options.m_count);
     return true;
   }
 
   CommandOptions m_options;
-
-  // Repeat command helpers
-  std::string m_repeat_command;
-  bool m_create_repeat_command_just_invoked = false;
   std::map<lldb::tid_t, std::unique_ptr<TraceInstructionDumper>> m_dumpers;
 };
 
 // CommandObjectTraceDumpInfo
 #define LLDB_OPTIONS_thread_trace_dump_info
 #include "CommandOptions.inc"
 
 class CommandObjectTraceDumpInfo : public CommandObjectIterateOverThreads {

lldb/source/Commands/Options.td

def thread_trace_dump_instructions_skip: Option<"skip", "s">,
     Desc<"How many instruction to skip from the end of the trace to start "
     "dumping instructions, or from the beginning if --forwards is provided">;
   def thread_trace_dump_instructions_raw : Option<"raw", "r">,
     Group<1>,
     Desc<"Dump only instruction address without disassembly nor symbol information.">;
   def thread_trace_dump_instructions_show_tsc : Option<"tsc", "t">,
     Group<1>,
     Desc<"For each instruction, print the corresponding timestamp counter if available.">;
+  def thread_trace_dump_instructions_continue: Option<"continue", "C">,
+    Group<1>,
+    Desc<"Continue dumping instructions right where the previous invocation of this "
+    "command was left, or from the beginning if this is the first invocation. The --skip "
+    "argument is discarded and the other arguments are preserved from the previous "
+    "invocation when possible.">;
 }
 
 let Command = "thread trace dump info" in {
   def thread_trace_dump_info_verbose : Option<"verbose", "v">, Group<1>,
     Desc<"show verbose thread trace dump info">;
 }
 
 let Command = "type summary add" in {

lldb/test/API/commands/trace/TestTraceDumpInfo.py

def testErrorMessages(self):
             substrs=["error: invalid target, create a target using the 'target create' command"],
             error=True)
 
         # We now check the output when there's a non-running target
         self.expect("target create " +
             os.path.join(self.getSourceDir(), "intelpt-trace", "a.out"))
 
         self.expect("thread trace dump info",
-            substrs=["error: invalid process"],
+            substrs=["error: Command requires a current process."],
             error=True)
 
         # Now we check the output when there's a running target without a trace
         self.expect("b main")
         self.expect("run")
 
         self.expect("thread trace dump info",
             substrs=["error: Process is not being traced"],

lldb/test/API/commands/trace/TestTraceDumpInstructions.py

def testErrorMessages(self):
             substrs=["error: invalid target, create a target using the 'target create' command"],
             error=True)
 
         # We now check the output when there's a non-running target
         self.expect("target create " +
             os.path.join(self.getSourceDir(), "intelpt-trace", "a.out"))
 
         self.expect("thread trace dump instructions",
-            substrs=["error: invalid process"],
+            substrs=["error: Command requires a current process."],
             error=True)
 
         # Now we check the output when there's a running target without a trace
         self.expect("b main")
         self.expect("run")
 
         self.expect("thread trace dump instructions",
             substrs=["error: Process is not being traced"],

lldb/test/API/commands/trace/TestTraceExport.py

def testErrorMessages(self):
             substrs=["error: invalid target, create a target using the 'target create' command"],
             error=True)
 
         # We now check the output when there's a non-running target
         self.expect("target create " +
             os.path.join(self.getSourceDir(), "intelpt-trace", "a.out"))
 
         self.expect(f"thread trace export ctf --file {ctf_test_file}",
-            substrs=["error: invalid process"],
+            substrs=["error: Command requires a current process."],
             error=True)
 
         # Now we check the output when there's a running target without a trace
         self.expect("b main")
         self.expect("run")
 
         self.expect(f"thread trace export ctf --file {ctf_test_file}",
             substrs=["error: Process is not being traced"],
def testHtrBasicSuperBlockPassSequenceCheck(self):
                 '0x4005af',
                 '0x4005b9: fast_handle_request(int)',
                 '0x4005d5: log_response(int)',
         ]
 
         data_index = index_of_first_layer_1_block
         for i in range(len(expected_block_names)):
             self.assertTrue(data[data_index + i]['name'] == expected_block_names[i])
-

lldb/test/API/commands/trace/TestTraceSave.py

def testErrorMessages(self):
             substrs=["error: invalid target, create a target using the 'target create' command"],
             error=True)
 
         # We now check the output when there's a non-running target
         self.expect("target create " +
             os.path.join(self.getSourceDir(), "intelpt-trace", "a.out"))
 
         self.expect("process trace save",
-            substrs=["error: invalid process"],
+            substrs=["error: Command requires a current process."],
             error=True)
 
         # Now we check the output when there's a running target without a trace
         self.expect("b main")
         self.expect("run")
 
         self.expect("process trace save",
             substrs=["error: Process is not being traced"],