[lldb][NFCI] TestEmulation should take a Stream ref

[bulbazord]

Summary

Instruction::TestEmulation takes a Stream * and checks it for validity.
However, this is unnecessary as we can always ensure that we never pass
nullptr for the Stream argument. The only use of
Instruction::TestEmulation currently is SBInstruction::TestEmulation
which gets the Stream from an SBStream, and SBStream::ref can
return a Stream & guaranteed.

[DavidSpickett]

LGTM. Always happy to see never-null pointers get updated.

[fdeazeve]

Thanks for finding those!

lldb/include/lldb/Core/Disassembler.h

public:
 
   virtual size_t Decode(const Disassembler &disassembler,
                         const DataExtractor &data,
                         lldb::offset_t data_offset) = 0;
 
   virtual void SetDescription(llvm::StringRef) {
   } // May be overridden in sub-classes that have descriptions.
 
-  lldb::OptionValueSP ReadArray(FILE *in_file, Stream *out_stream,
+  lldb::OptionValueSP ReadArray(FILE *in_file, Stream &out_stream,
                                 OptionValue::Type data_type);
 
-  lldb::OptionValueSP ReadDictionary(FILE *in_file, Stream *out_stream);
+  lldb::OptionValueSP ReadDictionary(FILE *in_file, Stream &out_stream);
 
   bool DumpEmulation(const ArchSpec &arch);
 
-  virtual bool TestEmulation(Stream *stream, const char *test_file_name);
+  virtual bool TestEmulation(Stream &stream, const char *test_file_name);
 
   bool Emulate(const ArchSpec &arch, uint32_t evaluate_options, void *baton,
                EmulateInstruction::ReadMemoryCallback read_mem_callback,
                EmulateInstruction::WriteMemoryCallback write_mem_calback,
                EmulateInstruction::ReadRegisterCallback read_reg_callback,
                EmulateInstruction::WriteRegisterCallback write_reg_callback);
 
   const Opcode &GetOpcode() const { return m_opcode; }

lldb/include/lldb/Core/EmulateInstruction.h

public:
   virtual bool ReadInstruction() = 0;
 
   virtual bool EvaluateInstruction(uint32_t evaluate_options) = 0;
 
   virtual InstructionCondition GetInstructionCondition() {
     return UnconditionalCondition;
   }
 
-  virtual bool TestEmulation(Stream *out_stream, ArchSpec &arch,
+  virtual bool TestEmulation(Stream &out_stream, ArchSpec &arch,
                              OptionValueDictionary *test_data) = 0;
 
   virtual std::optional<RegisterInfo>
   GetRegisterInfo(lldb::RegisterKind reg_kind, uint32_t reg_num) = 0;
 
   // Optional overrides
   virtual bool SetInstruction(const Opcode &insn_opcode,
                               const Address &inst_addr, Target *target);

lldb/source/API/SBInstruction.cpp

bool SBInstruction::TestEmulation(lldb::SBStream &output_stream,
   LLDB_INSTRUMENT_VA(this, output_stream, test_file);
 
   if (!m_opaque_sp)
     SetOpaque(lldb::DisassemblerSP(),
               lldb::InstructionSP(new PseudoInstruction()));
 
   lldb::InstructionSP inst_sp(GetOpaque());
   if (inst_sp)
-    return inst_sp->TestEmulation(output_stream.get(), test_file);
+    return inst_sp->TestEmulation(output_stream.ref(), test_file);
   return false;
 }

lldb/source/Core/Disassembler.cpp

bool Instruction::CanSetBreakpoint () {
   return !HasDelaySlot();
 }
 
 bool Instruction::HasDelaySlot() {
   // Default is false.
   return false;
 }
 
-OptionValueSP Instruction::ReadArray(FILE *in_file, Stream *out_stream,
+OptionValueSP Instruction::ReadArray(FILE *in_file, Stream &out_stream,
                                      OptionValue::Type data_type) {
   bool done = false;
   char buffer[1024];
 
   auto option_value_sp = std::make_shared<OptionValueArray>(1u << data_type);
 
   int idx = 0;
   while (!done) {
     if (!fgets(buffer, 1023, in_file)) {
-      out_stream->Printf(
+      out_stream.Printf(
           "Instruction::ReadArray:  Error reading file (fgets).\n");
       option_value_sp.reset();
       return option_value_sp;
     }
 
     std::string line(buffer);
 
     size_t len = line.size();
if (!line.empty()) {
       option_value_sp->GetAsArray()->InsertValue(idx, data_value_sp);
       ++idx;
     }
   }
 
   return option_value_sp;
 }
 
-OptionValueSP Instruction::ReadDictionary(FILE *in_file, Stream *out_stream) {
+OptionValueSP Instruction::ReadDictionary(FILE *in_file, Stream &out_stream) {
   bool done = false;
   char buffer[1024];
 
   auto option_value_sp = std::make_shared<OptionValueDictionary>();
   static constexpr llvm::StringLiteral encoding_key("data_encoding");
   OptionValue::Type data_type = OptionValue::eTypeInvalid;
 
   while (!done) {
     // Read the next line in the file
     if (!fgets(buffer, 1023, in_file)) {
-      out_stream->Printf(
+      out_stream.Printf(
           "Instruction::ReadDictionary: Error reading file (fgets).\n");
       option_value_sp.reset();
       return option_value_sp;
     }
 
     // Check to see if the line contains the end-of-dictionary marker ("}")
     std::string line(buffer);
 
if (!line.empty()) {
 
       bool reg_exp_success = g_reg_exp.Execute(line, &matches);
       std::string key;
       std::string value;
       if (reg_exp_success) {
         key = matches[1].str();
         value = matches[2].str();
       } else {
-        out_stream->Printf("Instruction::ReadDictionary: Failure executing "
-                           "regular expression.\n");
+        out_stream.Printf("Instruction::ReadDictionary: Failure executing "
         option_value_sp.reset();
         return option_value_sp;
       }
 
       // Check value to see if it's the start of an array or dictionary.
 
       lldb::OptionValueSP value_sp;
       assert(value.empty() == false);
if (!line.empty()) {
         option_value_sp->GetAsDictionary()->SetValueForKey(key, value_sp,
                                                            false);
     }
   }
 
   return option_value_sp;
 }
 
-bool Instruction::TestEmulation(Stream *out_stream, const char *file_name) {
-  if (!out_stream)
-    return false;
-
+bool Instruction::TestEmulation(Stream &out_stream, const char *file_name) {
   if (!file_name) {
-    out_stream->Printf("Instruction::TestEmulation:  Missing file_name.");
+    out_stream.Printf("Instruction::TestEmulation:  Missing file_name.");
     return false;
   }
   FILE *test_file = FileSystem::Instance().Fopen(file_name, "r");
   if (!test_file) {
-    out_stream->Printf(
+    out_stream.Printf(
         "Instruction::TestEmulation: Attempt to open test file failed.");
     return false;
   }
 
   char buffer[256];
   if (!fgets(buffer, 255, test_file)) {
-    out_stream->Printf(
+    out_stream.Printf(
         "Instruction::TestEmulation: Error reading first line of test file.\n");
     fclose(test_file);
     return false;
   }
 
   if (strncmp(buffer, "InstructionEmulationState={", 27) != 0) {
-    out_stream->Printf("Instructin::TestEmulation: Test file does not contain "
-                       "emulation state dictionary\n");
+    out_stream.Printf("Instructin::TestEmulation: Test file does not contain "
     fclose(test_file);
     return false;
   }
 
   // Read all the test information from the test file into an
   // OptionValueDictionary.
 
   OptionValueSP data_dictionary_sp(ReadDictionary(test_file, out_stream));
   if (!data_dictionary_sp) {
-    out_stream->Printf(
+    out_stream.Printf(
         "Instruction::TestEmulation:  Error reading Dictionary Object.\n");
     fclose(test_file);
     return false;
   }
 
   fclose(test_file);
 
   OptionValueDictionary *data_dictionary =
       data_dictionary_sp->GetAsDictionary();
   static constexpr llvm::StringLiteral description_key("assembly_string");
   static constexpr llvm::StringLiteral triple_key("triple");
 
   OptionValueSP value_sp = data_dictionary->GetValueForKey(description_key);
 
   if (!value_sp) {
-    out_stream->Printf("Instruction::TestEmulation:  Test file does not "
-                       "contain description string.\n");
+    out_stream.Printf("Instruction::TestEmulation:  Test file does not "
     return false;
   }
 
   SetDescription(value_sp->GetValueAs<llvm::StringRef>().value_or(""));
 
   value_sp = data_dictionary->GetValueForKey(triple_key);
   if (!value_sp) {
-    out_stream->Printf(
+    out_stream.Printf(
         "Instruction::TestEmulation: Test file does not contain triple.\n");
     return false;
   }
 
   ArchSpec arch;
   arch.SetTriple(
       llvm::Triple(value_sp->GetValueAs<llvm::StringRef>().value_or("")));
 
   bool success = false;
   std::unique_ptr<EmulateInstruction> insn_emulator_up(
       EmulateInstruction::FindPlugin(arch, eInstructionTypeAny, nullptr));
   if (insn_emulator_up)
     success =
         insn_emulator_up->TestEmulation(out_stream, arch, data_dictionary);
 
   if (success)
-    out_stream->Printf("Emulation test succeeded.");
+    out_stream.Printf("Emulation test succeeded.");
   else
-    out_stream->Printf("Emulation test failed.");
+    out_stream.Printf("Emulation test failed.");
 
   return success;
 }
 
 bool Instruction::Emulate(
     const ArchSpec &arch, uint32_t evaluate_options, void *baton,
     EmulateInstruction::ReadMemoryCallback read_mem_callback,
     EmulateInstruction::WriteMemoryCallback write_mem_callback,

lldb/source/Plugins/Instruction/ARM/EmulateInstructionARM.h

public:
 
   bool SetInstruction(const Opcode &insn_opcode, const Address &inst_addr,
                       Target *target) override;
 
   bool EvaluateInstruction(uint32_t evaluate_options) override;
 
   InstructionCondition GetInstructionCondition() override;
 
-  bool TestEmulation(Stream *out_stream, ArchSpec &arch,
+  bool TestEmulation(Stream &out_stream, ArchSpec &arch,
                      OptionValueDictionary *test_data) override;
 
   std::optional<RegisterInfo> GetRegisterInfo(lldb::RegisterKind reg_kind,
                                               uint32_t reg_num) override;
 
   bool CreateFunctionEntryUnwind(UnwindPlan &unwind_plan) override;
 
   uint32_t ArchVersion();

lldb/source/Plugins/Instruction/ARM/EmulateInstructionARM.cpp

 EmulateInstruction::InstructionCondition
 EmulateInstructionARM::GetInstructionCondition() {
   const uint32_t cond = CurrentCond(m_opcode.GetOpcode32());
   if (cond == 0xe || cond == 0xf || cond == UINT32_MAX)
     return EmulateInstruction::UnconditionalCondition;
   return cond;
 }
 
-bool EmulateInstructionARM::TestEmulation(Stream *out_stream, ArchSpec &arch,
+bool EmulateInstructionARM::TestEmulation(Stream &out_stream, ArchSpec &arch,
                                           OptionValueDictionary *test_data) {
   if (!test_data) {
-    out_stream->Printf("TestEmulation: Missing test data.\n");
+    out_stream.Printf("TestEmulation: Missing test data.\n");
     return false;
   }
 
   static constexpr llvm::StringLiteral opcode_key("opcode");
   static constexpr llvm::StringLiteral before_key("before_state");
   static constexpr llvm::StringLiteral after_key("after_state");
 
   OptionValueSP value_sp = test_data->GetValueForKey(opcode_key);
 
   uint32_t test_opcode;
   if ((value_sp.get() == nullptr) ||
       (value_sp->GetType() != OptionValue::eTypeUInt64)) {
-    out_stream->Printf("TestEmulation: Error reading opcode from test file.\n");
+    out_stream.Printf("TestEmulation: Error reading opcode from test file.\n");
     return false;
   }
   test_opcode = value_sp->GetValueAs<uint64_t>().value_or(0);
 
   if (arch.GetTriple().getArch() == llvm::Triple::thumb ||
       arch.IsAlwaysThumbInstructions()) {
     m_opcode_mode = eModeThumb;
     if (test_opcode < 0x10000)
       m_opcode.SetOpcode16(test_opcode, endian::InlHostByteOrder());
     else
       m_opcode.SetOpcode32(test_opcode, endian::InlHostByteOrder());
   } else if (arch.GetTriple().getArch() == llvm::Triple::arm) {
     m_opcode_mode = eModeARM;
     m_opcode.SetOpcode32(test_opcode, endian::InlHostByteOrder());
   } else {
-    out_stream->Printf("TestEmulation:  Invalid arch.\n");
+    out_stream.Printf("TestEmulation:  Invalid arch.\n");
     return false;
   }
 
   EmulationStateARM before_state;
   EmulationStateARM after_state;
 
   value_sp = test_data->GetValueForKey(before_key);
   if ((value_sp.get() == nullptr) ||
       (value_sp->GetType() != OptionValue::eTypeDictionary)) {
-    out_stream->Printf("TestEmulation:  Failed to find 'before' state.\n");
+    out_stream.Printf("TestEmulation:  Failed to find 'before' state.\n");
     return false;
   }
 
   OptionValueDictionary *state_dictionary = value_sp->GetAsDictionary();
   if (!before_state.LoadStateFromDictionary(state_dictionary)) {
-    out_stream->Printf("TestEmulation:  Failed loading 'before' state.\n");
+    out_stream.Printf("TestEmulation:  Failed loading 'before' state.\n");
     return false;
   }
 
   value_sp = test_data->GetValueForKey(after_key);
   if ((value_sp.get() == nullptr) ||
       (value_sp->GetType() != OptionValue::eTypeDictionary)) {
-    out_stream->Printf("TestEmulation:  Failed to find 'after' state.\n");
+    out_stream.Printf("TestEmulation:  Failed to find 'after' state.\n");
     return false;
   }
 
   state_dictionary = value_sp->GetAsDictionary();
   if (!after_state.LoadStateFromDictionary(state_dictionary)) {
-    out_stream->Printf("TestEmulation: Failed loading 'after' state.\n");
+    out_stream.Printf("TestEmulation: Failed loading 'after' state.\n");
     return false;
   }
 
   SetBaton((void *)&before_state);
   SetCallbacks(&EmulationStateARM::ReadPseudoMemory,
                &EmulationStateARM::WritePseudoMemory,
                &EmulationStateARM::ReadPseudoRegister,
                &EmulationStateARM::WritePseudoRegister);
 
   bool success = EvaluateInstruction(eEmulateInstructionOptionAutoAdvancePC);
   if (!success) {
-    out_stream->Printf("TestEmulation:  EvaluateInstruction() failed.\n");
+    out_stream.Printf("TestEmulation:  EvaluateInstruction() failed.\n");
     return false;
   }
 
   success = before_state.CompareState(after_state, out_stream);
   if (!success)
-    out_stream->Printf(
-        "TestEmulation:  State after emulation does not match 'after' state.\n");
+    out_stream.Printf("TestEmulation:  State after emulation does not match "
+                      "'after' state.\n");
 
   return success;
 }
 //
 //
 // const char *
 // EmulateInstructionARM::GetRegisterName (uint32_t reg_kind, uint32_t reg_num)
 //{

lldb/source/Plugins/Instruction/ARM/EmulationStateARM.h

public:
 
   void ClearPseudoRegisters();
 
   void ClearPseudoMemory();
 
   bool LoadStateFromDictionary(lldb_private::OptionValueDictionary *test_data);
 
   bool CompareState(EmulationStateARM &other_state,
-                    lldb_private::Stream *out_stream);
+                    lldb_private::Stream &out_stream);
 
   static size_t
   ReadPseudoMemory(lldb_private::EmulateInstruction *instruction, void *baton,
                    const lldb_private::EmulateInstruction::Context &context,
                    lldb::addr_t addr, void *dst, size_t length);
 
   static size_t
   WritePseudoMemory(lldb_private::EmulateInstruction *instruction, void *baton,

lldb/source/Plugins/Instruction/ARM/EmulationStateARM.cpp

bool EmulationStateARM::WritePseudoRegister(
   EmulationStateARM *pseudo_state = (EmulationStateARM *)baton;
   const uint32_t dwarf_reg_num = reg_info->kinds[eRegisterKindDWARF];
   assert(dwarf_reg_num != LLDB_INVALID_REGNUM);
   return pseudo_state->StorePseudoRegisterValue(dwarf_reg_num,
                                                 reg_value.GetAsUInt64());
 }
 
 bool EmulationStateARM::CompareState(EmulationStateARM &other_state,
-                                     Stream *out_stream) {
+                                     Stream &out_stream) {
   bool match = true;
 
   for (int i = 0; match && i < 17; ++i) {
     if (m_gpr[i] != other_state.m_gpr[i]) {
       match = false;
-      out_stream->Printf("r%d: 0x%x != 0x%x\n", i, m_gpr[i],
-                         other_state.m_gpr[i]);
+      out_stream.Printf("r%d: 0x%x != 0x%x\n", i, m_gpr[i],
     }
   }
 
   for (int i = 0; match && i < 32; ++i) {
     if (m_vfp_regs.s_regs[i] != other_state.m_vfp_regs.s_regs[i]) {
       match = false;
-      out_stream->Printf("s%d: 0x%x != 0x%x\n", i, m_vfp_regs.s_regs[i],
-                         other_state.m_vfp_regs.s_regs[i]);
+      out_stream.Printf("s%d: 0x%x != 0x%x\n", i, m_vfp_regs.s_regs[i],
     }
   }
 
   for (int i = 0; match && i < 16; ++i) {
     if (m_vfp_regs.d_regs[i] != other_state.m_vfp_regs.d_regs[i]) {
       match = false;
-      out_stream->Printf("d%d: 0x%" PRIx64 " != 0x%" PRIx64 "\n", i + 16,
-                         m_vfp_regs.d_regs[i],
-                         other_state.m_vfp_regs.d_regs[i]);
+      out_stream.Printf("d%d: 0x%" PRIx64 " != 0x%" PRIx64 "\n", i + 16,
+                        m_vfp_regs.d_regs[i], other_state.m_vfp_regs.d_regs[i]);
     }
   }
 
   // other_state is the expected state. If it has memory, check it.
   if (!other_state.m_memory.empty() && m_memory != other_state.m_memory) {
     match = false;
-    out_stream->Printf("memory does not match\n");
-    out_stream->Printf("got memory:\n");
+    out_stream.Printf("memory does not match\n");
+    out_stream.Printf("got memory:\n");
     for (auto p : m_memory)
-      out_stream->Printf("0x%08" PRIx64 ": 0x%08x\n", p.first, p.second);
-    out_stream->Printf("expected memory:\n");
+      out_stream.Printf("0x%08" PRIx64 ": 0x%08x\n", p.first, p.second);
+    out_stream.Printf("expected memory:\n");
     for (auto p : other_state.m_memory)
-      out_stream->Printf("0x%08" PRIx64 ": 0x%08x\n", p.first, p.second);
+      out_stream.Printf("0x%08" PRIx64 ": 0x%08x\n", p.first, p.second);
   }
 
   return match;
 }
 
 bool EmulationStateARM::LoadRegistersStateFromDictionary(
     OptionValueDictionary *reg_dict, char kind, int first_reg, int num) {
   StreamString sstr;

lldb/source/Plugins/Instruction/ARM64/EmulateInstructionARM64.h

bool SupportsEmulatingInstructionsOfType(
       lldb_private::InstructionType inst_type) override {
     return SupportsEmulatingInstructionsOfTypeStatic(inst_type);
   }
 
   bool ReadInstruction() override;
 
   bool EvaluateInstruction(uint32_t evaluate_options) override;
 
-  bool TestEmulation(lldb_private::Stream *out_stream,
+  bool TestEmulation(lldb_private::Stream &out_stream,
                      lldb_private::ArchSpec &arch,
                      lldb_private::OptionValueDictionary *test_data) override {
     return false;
   }
 
   std::optional<lldb_private::RegisterInfo>
   GetRegisterInfo(lldb::RegisterKind reg_kind, uint32_t reg_num) override;
 

lldb/source/Plugins/Instruction/LoongArch/EmulateInstructionLoongArch.h

public:
 
   bool SupportsEmulatingInstructionsOfType(InstructionType inst_type) override {
     return SupportsThisInstructionType(inst_type);
   }
 
   bool SetTargetTriple(const ArchSpec &arch) override;
   bool ReadInstruction() override;
   bool EvaluateInstruction(uint32_t options) override;
-  bool TestEmulation(Stream *out_stream, ArchSpec &arch,
+  bool TestEmulation(Stream &out_stream, ArchSpec &arch,
                      OptionValueDictionary *test_data) override;
 
   std::optional<RegisterInfo> GetRegisterInfo(lldb::RegisterKind reg_kind,
                                               uint32_t reg_num) override;
   lldb::addr_t ReadPC(bool *success);
   bool WritePC(lldb::addr_t pc);
   bool IsLoongArch64() { return m_arch_subtype == llvm::Triple::loongarch64; }
   bool TestExecute(uint32_t inst);

lldb/source/Plugins/Instruction/LoongArch/EmulateInstructionLoongArch.cpp

EmulateInstructionLoongArch::GetRegisterInfo(lldb::RegisterKind reg_kind,
   return array[reg_index];
 }
 
 bool EmulateInstructionLoongArch::SetTargetTriple(const ArchSpec &arch) {
   return SupportsThisArch(arch);
 }
 
 bool EmulateInstructionLoongArch::TestEmulation(
-    Stream *out_stream, ArchSpec &arch, OptionValueDictionary *test_data) {
+    Stream &out_stream, ArchSpec &arch, OptionValueDictionary *test_data) {
   return false;
 }
 
 void EmulateInstructionLoongArch::Initialize() {
   PluginManager::RegisterPlugin(GetPluginNameStatic(),
                                 GetPluginDescriptionStatic(), CreateInstance);
 }
 

lldb/source/Plugins/Instruction/MIPS/EmulateInstructionMIPS.h

public:
   bool ReadInstruction() override;
 
   bool EvaluateInstruction(uint32_t evaluate_options) override;
 
   bool SetInstruction(const lldb_private::Opcode &insn_opcode,
                       const lldb_private::Address &inst_addr,
                       lldb_private::Target *target) override;
 
-  bool TestEmulation(lldb_private::Stream *out_stream,
+  bool TestEmulation(lldb_private::Stream &out_stream,
                      lldb_private::ArchSpec &arch,
                      lldb_private::OptionValueDictionary *test_data) override {
     return false;
   }
 
   std::optional<lldb_private::RegisterInfo>
   GetRegisterInfo(lldb::RegisterKind reg_kind, uint32_t reg_num) override;
 

lldb/source/Plugins/Instruction/MIPS64/EmulateInstructionMIPS64.h

bool SupportsEmulatingInstructionsOfType(
       lldb_private::InstructionType inst_type) override {
     return SupportsEmulatingInstructionsOfTypeStatic(inst_type);
   }
 
   bool ReadInstruction() override;
 
   bool EvaluateInstruction(uint32_t evaluate_options) override;
 
-  bool TestEmulation(lldb_private::Stream *out_stream,
+  bool TestEmulation(lldb_private::Stream &out_stream,
                      lldb_private::ArchSpec &arch,
                      lldb_private::OptionValueDictionary *test_data) override {
     return false;
   }
 
   std::optional<lldb_private::RegisterInfo>
   GetRegisterInfo(lldb::RegisterKind reg_kind, uint32_t reg_num) override;
 

lldb/source/Plugins/Instruction/PPC64/EmulateInstructionPPC64.h

public:
   bool SupportsEmulatingInstructionsOfType(InstructionType inst_type) override {
     return SupportsEmulatingInstructionsOfTypeStatic(inst_type);
   }
 
   bool ReadInstruction() override;
 
   bool EvaluateInstruction(uint32_t evaluate_options) override;
 
-  bool TestEmulation(Stream *out_stream, ArchSpec &arch,
+  bool TestEmulation(Stream &out_stream, ArchSpec &arch,
                      OptionValueDictionary *test_data) override {
     return false;
   }
 
   std::optional<RegisterInfo> GetRegisterInfo(lldb::RegisterKind reg_kind,
                                               uint32_t reg_num) override;
 
   bool CreateFunctionEntryUnwind(UnwindPlan &unwind_plan) override;

lldb/source/Plugins/Instruction/RISCV/EmulateInstructionRISCV.h

public:
 
   bool SupportsEmulatingInstructionsOfType(InstructionType inst_type) override {
     return SupportsThisInstructionType(inst_type);
   }
 
   bool SetTargetTriple(const ArchSpec &arch) override;
   bool ReadInstruction() override;
   bool EvaluateInstruction(uint32_t options) override;
-  bool TestEmulation(Stream *out_stream, ArchSpec &arch,
+  bool TestEmulation(Stream &out_stream, ArchSpec &arch,
                      OptionValueDictionary *test_data) override;
   std::optional<RegisterInfo> GetRegisterInfo(lldb::RegisterKind reg_kind,
                                               uint32_t reg_num) override;
 
   std::optional<lldb::addr_t> ReadPC();
   bool WritePC(lldb::addr_t pc);
 
   std::optional<DecodeResult> ReadInstructionAt(lldb::addr_t addr);

lldb/source/Plugins/Instruction/RISCV/EmulateInstructionRISCV.cpp

EmulateInstructionRISCV::GetRegisterInfo(RegisterKind reg_kind,
 
   return array[reg_index];
 }
 
 bool EmulateInstructionRISCV::SetTargetTriple(const ArchSpec &arch) {
   return SupportsThisArch(arch);
 }
 
-bool EmulateInstructionRISCV::TestEmulation(Stream *out_stream, ArchSpec &arch,
+bool EmulateInstructionRISCV::TestEmulation(Stream &out_stream, ArchSpec &arch,
                                             OptionValueDictionary *test_data) {
   return false;
 }
 
 void EmulateInstructionRISCV::Initialize() {
   PluginManager::RegisterPlugin(GetPluginNameStatic(),
                                 GetPluginDescriptionStatic(), CreateInstance);
 }