[lldb/Core] Change large function threshold variable into a setting.

[mib]

Summary

This patch replaces the static large function threshold variable with a
global debugger setting (stop-disassembly-max-size).

The default threshold is now set to 32KB (instead of 8KB) and can be modified.

rdar://74726362

Signed-off-by: Med Ismail Bennani <[e-mail]>

[JDevlieghere]

lldb/include/lldb/Core/Debugger.h

249

This seems like it could have a better name, how about DisassemblyTreshold? If this only used when stopped (like StopDisassemblyCount) then maybe add the Stop prefix here too.

[mib]

Renamed setting to stop-disassembly-size.

[JDevlieghere]

lldb/source/Core/CoreProperties.td

31

Nit, let's move this next to StopDisassemblyCount and StopDisassemblyDisplay.

31

Sorry to go on about this but now it doesn't convey that it's the maximum size. Maybe stop-disassembly-max-size or stop-disassembly-size-threshold.

[mib]

Address @JDevlieghere comments.

[JDevlieghere]

LGTM. Thanks for bearing with me!

[labath]

As the author of this logic, I want to note that the original limit I chose was very arbitrary, and 32k (or any other small-ish number would work equally well). The main objective was to disable accidental multi-megabyte disassemblies (which can happen when the object file has no symbol information).

I'm not actually opposed to the, just wanting to make sure you're not adding it on my account.

[labath]

In D97486#2596523, @labath wrote:

I'm not actually opposed to the, just wanting to make sure you're not adding it on my account.

to the setting

[mib]

In D97486#2596523, @labath wrote:

As the author of this logic, I want to note that the original limit I chose was very arbitrary, and 32k (or any other small-ish number would work equally well). The main objective was to disable accidental multi-megabyte disassemblies (which can happen when the object file has no symbol information).

I'm not actually opposed to the, just wanting to make sure you're not adding it on my account.

I made that change after being requested to increase the limit. I thought turning it into a setting gives the user more flexibility.

lldb/include/lldb/Core/Debugger.h

 //===-- Debugger.h ----------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_CORE_DEBUGGER_H
 #define LLDB_CORE_DEBUGGER_H
 
 #include <stdint.h>
 
 #include <memory>
 #include <vector>
 
 #include "lldb/Core/FormatEntity.h"
 #include "lldb/Core/IOHandler.h"
 #include "lldb/Core/SourceManager.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/UserSettingsController.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/Terminal.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Platform.h"
public:
   bool GetAutoConfirm() const;
 
   const FormatEntity::Entry *GetDisassemblyFormat() const;
 
   const FormatEntity::Entry *GetFrameFormat() const;
 
   const FormatEntity::Entry *GetFrameFormatUnique() const;
 
+  uint32_t GetStopDisassemblySize() const;
+
   const FormatEntity::Entry *GetThreadFormat() const;
 
   const FormatEntity::Entry *GetThreadStopFormat() const;
 
   lldb::ScriptLanguage GetScriptLanguage() const;
 
   bool SetScriptLanguage(lldb::ScriptLanguage script_lang);
 

lldb/source/Commands/CommandObjectDisassemble.cpp

 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 
 static constexpr unsigned default_disasm_byte_size = 32;
 static constexpr unsigned default_disasm_num_ins = 4;
-static constexpr unsigned large_function_threshold = 8000;
 
 using namespace lldb;
 using namespace lldb_private;
 
 #define LLDB_OPTIONS_disassemble
 #include "CommandOptions.inc"
 
 CommandObjectDisassemble::CommandOptions::CommandOptions()
: CommandObjectParsed(
           "disassemble [<cmd-options>]", eCommandRequiresTarget),
       m_options() {}
 
 CommandObjectDisassemble::~CommandObjectDisassemble() = default;
 
 llvm::Error CommandObjectDisassemble::CheckRangeSize(const AddressRange &range,
                                                      llvm::StringRef what) {
   if (m_options.num_instructions > 0 || m_options.force ||
-      range.GetByteSize() < large_function_threshold)
+      range.GetByteSize() < GetDebugger().GetStopDisassemblySize())
     return llvm::Error::success();
   StreamString msg;
   msg << "Not disassembling " << what << " because it is very large ";
   range.Dump(&msg, &GetSelectedTarget(), Address::DumpStyleLoadAddress,
              Address::DumpStyleFileAddress);
   msg << ". To disassemble specify an instruction count limit, start/stop "
          "addresses or use the --force option.";
   return llvm::createStringError(llvm::inconvertibleErrorCode(),

lldb/source/Core/CoreProperties.td

let Definition = "debugger" in {
   def DisassemblyFormat: Property<"disassembly-format", "FormatEntity">,
     Global,
     DefaultStringValue<"{${function.initial-function}{${module.file.basename}`}{${function.name-without-args}}:\\\\n}{${function.changed}\\\\n{${module.file.basename}`}{${function.name-without-args}}:\\\\n}{${ansi.fg.yellow}${current-pc-arrow}${ansi.normal} }${addr-file-or-load}{ <${function.concrete-only-addr-offset-no-padding}>}: ">,
     Desc<"The default disassembly format string to use when disassembling instruction sequences.">;
   def FrameFormat: Property<"frame-format", "FormatEntity">,
     Global,
     DefaultStringValue<"frame #${frame.index}: ${ansi.fg.yellow}${frame.pc}${ansi.normal}{ ${module.file.basename}{`${function.name-with-args}{${frame.no-debug}${function.pc-offset}}}}{ at ${ansi.fg.cyan}${line.file.basename}${ansi.normal}:${ansi.fg.yellow}${line.number}${ansi.normal}{:${ansi.fg.yellow}${line.column}${ansi.normal}}}{${function.is-optimized} [opt]}{${frame.is-artificial} [artificial]}\\\\n">,
     Desc<"The default frame format string to use when displaying stack frame information for threads.">;
+  def StopDisassemblySize: Property<"stop-disassembly-size", "UInt64">,
+    Global,
+    DefaultUnsignedValue<32000>,
+    Desc<"The size limit to use when disassembling large functions (default: 32KB).">;
   def NotiftVoid: Property<"notify-void", "Boolean">,
     Global,
     DefaultFalse,
     Desc<"Notify the user explicitly if an expression returns void (default: false).">;
   def Prompt: Property<"prompt", "String">,
     Global,
     DefaultEnumValue<"OptionValueString::eOptionEncodeCharacterEscapeSequences">,
     DefaultStringValue<"(lldb) ">,

lldb/source/Core/Debugger.cpp

 //===-- Debugger.cpp ------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/Debugger.h"
 
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Core/FormatEntity.h"
 #include "lldb/Core/Mangled.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/StreamAsynchronousIO.h"
 #include "lldb/Core/StreamFile.h"
const FormatEntity::Entry *Debugger::GetFrameFormat() const {
   return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx);
 }
 
 const FormatEntity::Entry *Debugger::GetFrameFormatUnique() const {
   const uint32_t idx = ePropertyFrameFormatUnique;
   return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx);
 }
 
+uint32_t Debugger::GetStopDisassemblySize() const {
+  const uint32_t idx = ePropertyStopDisassemblySize;
+  return m_collection_sp->GetPropertyAtIndexAsUInt64(
+      nullptr, idx, g_debugger_properties[idx].default_uint_value);
+}
+
 bool Debugger::GetNotifyVoid() const {
   const uint32_t idx = ePropertyNotiftVoid;
   return m_collection_sp->GetPropertyAtIndexAsBoolean(
       nullptr, idx, g_debugger_properties[idx].default_uint_value != 0);
 }
 
 llvm::StringRef Debugger::GetPrompt() const {
   const uint32_t idx = ePropertyPrompt;

lldb/test/Shell/Commands/command-disassemble-process.yaml

 # REQUIRES: x86
 
 # RUN: yaml2obj --docnum=1 -DMAIN_SIZE=8 %s -o %T/command-disassemble-process.exe
 # RUN: yaml2obj --docnum=1 -DMAIN_SIZE=8000 %s -o %T/command-disassemble-process.big.exe
 # RUN: yaml2obj --docnum=2 %s -o %t
 
 # RUN: %lldb -c %t %T/command-disassemble-process.exe \
 # RUN:   -o "settings set interpreter.stop-command-source-on-error false" \
 # RUN:   -s %S/Inputs/command-disassemble-process.lldbinit -o exit 2>&1 \
 # RUN:   | FileCheck %s
 
 # RUN: %lldb -c %t %T/command-disassemble-process.big.exe \
+# RUN:   -o "settings set stop-disassembly-size 8000" \
 # RUN:   -o disassemble -o exit 2>&1 | FileCheck %s --check-prefix=BIG
 
 # CHECK:       (lldb) disassemble
 # CHECK-NEXT: command-disassemble-process.exe`main:
 # CHECK-NEXT:     0x4002 <+0>: addb   %al, (%rcx)
 # CHECK-NEXT: ->  0x4004 <+2>: addb   %al, (%rdx)
 # CHECK-NEXT:     0x4006 <+4>: addb   %al, (%rbx)
 # CHECK-NEXT:     0x4008 <+6>: addb   %al, (%rsi)

lldb/test/Shell/Commands/command-disassemble.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux %s -o %t
 # RUN: %lldb %t -o "settings set interpreter.stop-command-source-on-error false" \
+# RUN:   -o "settings set stop-disassembly-size 8000" \
 # RUN:   -s %S/Inputs/command-disassemble.lldbinit -o exit 2>&1 | FileCheck %s
 
 # CHECK:      (lldb) disassemble
 # CHECK-NEXT: error: Cannot disassemble around the current function without a selected frame.
 # CHECK-EMPTY:
 # CHECK-NEXT: (lldb) disassemble --line
 # CHECK-NEXT: error: Cannot disassemble around the current line without a selected frame.
 # CHECK-EMPTY: