[lldb] Don't dissasemble large functions by default

[labath]

Summary

If we have a binary without symbol information (and without
LC_FUNCTION_STARTS, if on a mac), then we have to resort to using
heuristics to determine the function boundaries. However, these don't
always work, and so we can easily end up thinking we have functions
which are several megabytes in size. Attempting to (accidentally)
disassemble these can take a very long time spam the terminal with
thousands of lines of disassembly.

This patch works around that problem by adding a sanity check to the
disassemble command. If we are about to disassemble a function which is
larger than a certain threshold, we will refuse to disassemble such a
function unless the user explicitly specifies the number of instructions
to disassemble, or start/stop addresses for disassembly.

The threshold is currently fairly aggressive (4000 bytes ~~ 1000
instructions). If needed, we can increase it, or even make it
configurable.

[JDevlieghere]

Looks good to me.

lldb/source/Commands/CommandObjectDisassemble.cpp

231

nit: I don't think we need either of these commas.

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

93

Cool, I didn't realize this was possible.

[jingham]

Instead of just printing out the range, can we print out the disassemble command you would run to actually disassemble the range?

Also, I think we should add a --force option since if you were using this in a script you wouldn't get a chance to respond to the error.

[labath]

In D79789#2032008, @jingham wrote:

Instead of just printing out the range, can we print out the disassemble command you would run to actually disassemble the range?

Also, I think we should add a --force option since if you were using this in a script you wouldn't get a chance to respond to the error.

Yes, I've been thinking about a --force option too. You're right that this is a friendlier interface for scripting purposes.

The reason I wanted to print the range was to give the user a chance to pause and say "yes, I really don't want to disassemble all of *that*". With a --force option, do you think it's necessary to print the repeat command? It seems that doing a "<Up>--force<Return> would be more straight-forward than copy-pasting a chunk of text (and I don't believe we currently have a way to fetch the original command line from within a CommandObject implementation).

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

93

It's a very recent addition. It runs as a textual pre-processing step, so you can use it to do all the evi^H^H^Hnice things you can with a c preprocessor.

[labath]

Remove commas, add --force.

[jingham]

If you have --force, then the address range is informational, in which case having the full command would be more confusing than anything. So this is fine, thanks for adding it.

I thought briefly about whether we should also add a setting for this. But if it is something that you come across often you can just re-alias di to disassemble --force. I used to think we needed to always provide global settings for this sort of behavior, but if the setting just controls the behavior of one command, I'm beginning to think using aliases is better than adding more and more stuff to the settings.

I agree you want to print out the range. Many of the times you get huge functions, they aren't actually huge, they just look that way because we're just missing the subsequent symbols. So the user might be disassembling something they know is a small function, and we need to give them some clue to why we think that's not so.

This looks fine to me.

[shafik]

Pavel, I think this broke the green dragon bots: http://lab.llvm.org:8080/green/view/LLDB/job/lldb-cmake/18207/

[shafik]

I reverted this it breaks TestFoundationDisassembly.py.

lldb/source/Commands/CommandObjectDisassemble.h

public:
     bool frame_line;
     std::string plugin_name;
     std::string flavor_string;
     ArchSpec arch;
     bool some_location_specified; // If no location was specified, we'll select
                                   // "at_pc".  This should be set
     // in SetOptionValue if anything the selects a location is set.
     lldb::addr_t symbol_containing_addr;
+    bool force = false;
   };
 
   CommandObjectDisassemble(CommandInterpreter &interpreter);
 
   ~CommandObjectDisassemble() override;
 
   Options *GetOptions() override { return &m_options; }
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override;
 
-  llvm::Expected<std::vector<AddressRange>> GetRangesForSelectedMode();
+  llvm::Expected<std::vector<AddressRange>>
+  GetRangesForSelectedMode(CommandReturnObject &result);
 
   llvm::Expected<std::vector<AddressRange>> GetContainingAddressRanges();
   llvm::Expected<std::vector<AddressRange>> GetCurrentFunctionRanges();
   llvm::Expected<std::vector<AddressRange>> GetCurrentLineRanges();
-  llvm::Expected<std::vector<AddressRange>> GetNameRanges();
+  llvm::Expected<std::vector<AddressRange>>
+  GetNameRanges(CommandReturnObject &result);
   llvm::Expected<std::vector<AddressRange>> GetPCRanges();
   llvm::Expected<std::vector<AddressRange>> GetStartEndAddressRanges();
 
+  llvm::Error CheckRangeSize(const AddressRange &range, llvm::StringRef what);
+
   CommandOptions m_options;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_COMMANDS_COMMANDOBJECTDISASSEMBLE_H

lldb/source/Commands/CommandObjectDisassemble.cpp

 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/Options.h"
 #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"
 
-#define DEFAULT_DISASM_BYTE_SIZE 32
-#define DEFAULT_DISASM_NUM_INS 4
+static constexpr unsigned default_disasm_byte_size = 32;
+static constexpr unsigned default_disasm_num_ins = 4;
+static constexpr unsigned large_function_threshold = 4000;
 
 using namespace lldb;
 using namespace lldb_private;
 
 #define LLDB_OPTIONS_disassemble
 #include "CommandOptions.inc"
 
 CommandObjectDisassemble::CommandOptions::CommandOptions()
Status CommandObjectDisassemble::CommandOptions::SetOptionValue(
   case 'a': {
     symbol_containing_addr = OptionArgParser::ToAddress(
         execution_context, option_arg, LLDB_INVALID_ADDRESS, &error);
     if (symbol_containing_addr != LLDB_INVALID_ADDRESS) {
       some_location_specified = true;
     }
   } break;
 
+  case '\x01':
+    force = true;
+    break;
+
   default:
     llvm_unreachable("Unimplemented option");
   }
 
   return error;
 }
 
 void CommandObjectDisassemble::CommandOptions::OptionParsingStarting(
if (target) {
     } else
       flavor_string.assign("default");
 
   } else
     flavor_string.assign("default");
 
   arch.Clear();
   some_location_specified = false;
+  force = false;
 }
 
 Status CommandObjectDisassemble::CommandOptions::OptionParsingFinished(
     ExecutionContext *execution_context) {
   if (!some_location_specified)
     current_function = true;
   return Status();
 }
: CommandObjectParsed(
           "Disassemble specified instructions in the current target.  "
           "Defaults to the current function for the current thread and "
           "stack frame.",
           "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)
+    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(),
+                                 msg.GetString());
+}
+
 llvm::Expected<std::vector<AddressRange>>
 CommandObjectDisassemble::GetContainingAddressRanges() {
   std::vector<AddressRange> ranges;
   const auto &get_range = [&](Address addr) {
     ModuleSP module_sp(addr.GetModule());
     SymbolContext sc;
     bool resolve_tail_call_address = true;
     addr.GetModule()->ResolveSymbolContextForAddress(
CommandObjectDisassemble::GetContainingAddressRanges() {
   }
 
   if (ranges.empty()) {
     return llvm::createStringError(
         llvm::inconvertibleErrorCode(),
         "Could not find function bounds for address 0x%" PRIx64,
         m_options.symbol_containing_addr);
   }
+
+  if (llvm::Error err = CheckRangeSize(ranges[0], "the function"))
+    return std::move(err);
   return ranges;
 }
 
 llvm::Expected<std::vector<AddressRange>>
 CommandObjectDisassemble::GetCurrentFunctionRanges() {
   StackFrame *frame = m_exe_ctx.GetFramePtr();
   if (!frame) {
     return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                    "Cannot disassemble around the current "
                                    "function without a selected frame.\n");
   }
   SymbolContext sc(
       frame->GetSymbolContext(eSymbolContextFunction | eSymbolContextSymbol));
   AddressRange range;
   if (sc.function)
     range = sc.function->GetAddressRange();
   else if (sc.symbol && sc.symbol->ValueIsAddress()) {
     range = {sc.symbol->GetAddress(), sc.symbol->GetByteSize()};
   } else
-    range = {frame->GetFrameCodeAddress(), DEFAULT_DISASM_BYTE_SIZE};
+    range = {frame->GetFrameCodeAddress(), default_disasm_byte_size};
 
+  if (llvm::Error err = CheckRangeSize(range, "the current function"))
+    return std::move(err);
   return std::vector<AddressRange>{range};
 }
 
 llvm::Expected<std::vector<AddressRange>>
 CommandObjectDisassemble::GetCurrentLineRanges() {
   StackFrame *frame = m_exe_ctx.GetFramePtr();
   if (!frame) {
     return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                    "Cannot disassemble around the current "
                                    "line without a selected frame.\n");
   }
 
   LineEntry pc_line_entry(
       frame->GetSymbolContext(eSymbolContextLineEntry).line_entry);
   if (pc_line_entry.IsValid())
     return std::vector<AddressRange>{pc_line_entry.range};
 
   // No line entry, so just disassemble around the current pc
   m_options.show_mixed = false;
   return GetPCRanges();
 }
 
 llvm::Expected<std::vector<AddressRange>>
-CommandObjectDisassemble::GetNameRanges() {
+CommandObjectDisassemble::GetNameRanges(CommandReturnObject &result) {
   ConstString name(m_options.func_name.c_str());
   const bool include_symbols = true;
   const bool include_inlines = true;
 
   // Find functions matching the given name.
   SymbolContextList sc_list;
   GetSelectedTarget().GetImages().FindFunctions(
       name, eFunctionNameTypeAuto, include_symbols, include_inlines, sc_list);
 
   std::vector<AddressRange> ranges;
+  llvm::Error range_errs = llvm::Error::success();
   AddressRange range;
   const uint32_t scope =
       eSymbolContextBlock | eSymbolContextFunction | eSymbolContextSymbol;
   const bool use_inline_block_range = true;
   for (SymbolContext sc : sc_list.SymbolContexts()) {
     for (uint32_t range_idx = 0;
          sc.GetAddressRange(scope, range_idx, use_inline_block_range, range);
          ++range_idx) {
+      if (llvm::Error err = CheckRangeSize(range, "a range"))
+        range_errs = joinErrors(std::move(range_errs), std::move(err));
+      else
         ranges.push_back(range);
     }
   }
   if (ranges.empty()) {
+    if (range_errs)
+      return std::move(range_errs);
     return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                    "Unable to find symbol with name '%s'.\n",
                                    name.GetCString());
   }
+  if (range_errs)
+    result.AppendWarning(toString(std::move(range_errs)));
   return ranges;
 }
 
 llvm::Expected<std::vector<AddressRange>>
 CommandObjectDisassemble::GetPCRanges() {
   StackFrame *frame = m_exe_ctx.GetFramePtr();
   if (!frame) {
     return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                    "Cannot disassemble around the current "
                                    "PC without a selected frame.\n");
   }
 
   if (m_options.num_instructions == 0) {
     // Disassembling at the PC always disassembles some number of
     // instructions (not the whole function).
-    m_options.num_instructions = DEFAULT_DISASM_NUM_INS;
+    m_options.num_instructions = default_disasm_num_ins;
   }
   return std::vector<AddressRange>{{frame->GetFrameCodeAddress(), 0}};
 }
 
 llvm::Expected<std::vector<AddressRange>>
 CommandObjectDisassemble::GetStartEndAddressRanges() {
   addr_t size = 0;
   if (m_options.end_addr != LLDB_INVALID_ADDRESS) {
     if (m_options.end_addr <= m_options.start_addr) {
       return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                      "End address before start address.");
     }
     size = m_options.end_addr - m_options.start_addr;
   }
   return std::vector<AddressRange>{{Address(m_options.start_addr), size}};
 }
 
 llvm::Expected<std::vector<AddressRange>>
-CommandObjectDisassemble::GetRangesForSelectedMode() {
+CommandObjectDisassemble::GetRangesForSelectedMode(
+    CommandReturnObject &result) {
   if (m_options.symbol_containing_addr != LLDB_INVALID_ADDRESS)
     return CommandObjectDisassemble::GetContainingAddressRanges();
   if (m_options.current_function)
     return CommandObjectDisassemble::GetCurrentFunctionRanges();
   if (m_options.frame_line)
     return CommandObjectDisassemble::GetCurrentLineRanges();
   if (!m_options.func_name.empty())
-    return CommandObjectDisassemble::GetNameRanges();
+    return CommandObjectDisassemble::GetNameRanges(result);
   if (m_options.start_addr != LLDB_INVALID_ADDRESS)
     return CommandObjectDisassemble::GetStartEndAddressRanges();
   return CommandObjectDisassemble::GetPCRanges();
 }
 
 bool CommandObjectDisassemble::DoExecute(Args &command,
                                          CommandReturnObject &result) {
   Target *target = &GetSelectedTarget();
if (m_options.show_mixed)
     options |= Disassembler::eOptionMarkPCSourceLine;
 
   if (m_options.show_bytes)
     options |= Disassembler::eOptionShowBytes;
 
   if (m_options.raw)
     options |= Disassembler::eOptionRawOuput;
 
-  llvm::Expected<std::vector<AddressRange>> ranges = GetRangesForSelectedMode();
+  llvm::Expected<std::vector<AddressRange>> ranges =
+      GetRangesForSelectedMode(result);
   if (!ranges) {
     result.AppendError(toString(ranges.takeError()));
     result.SetStatus(eReturnStatusFailed);
     return result.Succeeded();
   }
 
   bool print_sc_header = ranges->size() > 1;
   for (AddressRange cur_range : *ranges) {
     Disassembler::Limit limit;
     if (m_options.num_instructions == 0) {
       limit = {Disassembler::Limit::Bytes, cur_range.GetByteSize()};
       if (limit.value == 0)
-        limit.value = DEFAULT_DISASM_BYTE_SIZE;
+        limit.value = default_disasm_byte_size;
     } else {
       limit = {Disassembler::Limit::Instructions, m_options.num_instructions};
     }
     if (Disassembler::Disassemble(
             GetDebugger(), m_options.arch, plugin_name, flavor_string,
             m_exe_ctx, cur_range.GetBaseAddress(), limit, m_options.show_mixed,
             m_options.show_mixed ? m_options.num_lines_context : 0, options,
             result.GetOutputStream())) {
       result.SetStatus(eReturnStatusSuccessFinishResult);
     } else {
       if (m_options.symbol_containing_addr != LLDB_INVALID_ADDRESS) {
         result.AppendErrorWithFormat(
             "Failed to disassemble memory in function at 0x%8.8" PRIx64 ".\n",
             m_options.symbol_containing_addr);
       } else {
         result.AppendErrorWithFormat(
             "Failed to disassemble memory at 0x%8.8" PRIx64 ".\n",
             cur_range.GetBaseAddress().GetLoadAddress(target));
       }
       result.SetStatus(eReturnStatusFailed);
     }
     if (print_sc_header)
-      result.AppendMessage("\n");
+      result.GetOutputStream() << "\n";
   }
 
   return result.Succeeded();
 }

lldb/source/Commands/Options.td

def disassemble_options_flavor : Option<"flavor", "F">,
     "architectures, att and intel.">;
   def disassemble_options_arch : Option<"arch", "A">, Arg<"Architecture">,
     Desc<"Specify the architecture to use from cross disassembly.">;
   def disassemble_options_start_address : Option<"start-address", "s">,
     Groups<[1,2]>, Arg<"AddressOrExpression">, Required,
     Desc<"Address at which to start disassembling.">;
   def disassemble_options_end_address : Option<"end-address", "e">, Group<1>,
     Arg<"AddressOrExpression">, Desc<"Address at which to end disassembling.">;
-  def disassemble_options_count : Option<"count", "c">, Groups<[2,3,4,5]>,
+  def disassemble_options_count : Option<"count", "c">, Groups<[2,3,4,5,7]>,
     Arg<"NumLines">, Desc<"Number of instructions to display.">;
   def disassemble_options_name : Option<"name", "n">, Group<3>,
     Arg<"FunctionName">, Completion<"Symbol">,
     Desc<"Disassemble entire contents of the given function name.">;
   def disassemble_options_frame : Option<"frame", "f">, Group<4>,
     Desc<"Disassemble from the start of the current frame's function.">;
   def disassemble_options_pc : Option<"pc", "p">, Group<5>,
     Desc<"Disassemble around the current pc.">;
   def disassemble_options_line : Option<"line", "l">, Group<6>,
     Desc<"Disassemble the current frame's current source line instructions if"
     "there is debug line table information, else disassemble around the pc.">;
   def disassemble_options_address : Option<"address", "a">, Group<7>,
     Arg<"AddressOrExpression">,
     Desc<"Disassemble function containing this address.">;
+  def disassemble_options_force : Option<"force", "\\x01">, Groups<[2,3,4,5,7]>,
+    Desc<"Force dissasembly of large functions.">;
 }
 
 let Command = "expression" in {
   def expression_options_all_threads : Option<"all-threads", "a">,
     Groups<[1,2]>, Arg<"Boolean">, Desc<"Should we run all threads if the "
     "execution doesn't complete on one thread.">;
   def expression_options_ignore_breakpoints : Option<"ignore-breakpoints", "i">,
     Groups<[1,2]>, Arg<"Boolean">,

lldb/test/Shell/Commands/Inputs/command-disassemble.lldbinit

 disassemble
 disassemble --line
 disassemble --frame
 disassemble --pc
 disassemble --start-address 0x0
 disassemble --start-address 0x4 --end-address 0x8
 disassemble --start-address 0x8 --end-address 0x4
 disassemble --address 0x0
-disassemble --address 0xdead
+disassemble --address 0xdeadb
+disassemble --address 0x100
+disassemble --address 0x100 --count 3
+disassemble --address 0x100 --force
 disassemble --start-address 0x0 --count 7
 disassemble --start-address 0x0 --end-address 0x20 --count 7
-disassemble --address 0x0 --count 7
+disassemble --name case1
+disassemble --name case2
+disassemble --name case3
+disassemble --name case3 --count 3

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

 # REQUIRES: x86
 
-# RUN: yaml2obj --docnum=1 %s > %T/command-disassemble-process.exe
+# RUN: yaml2obj --docnum=1 -DMAIN_SIZE=8 %s > %T/command-disassemble-process.exe
+# RUN: yaml2obj --docnum=1 -DMAIN_SIZE=4000 %s > %T/command-disassemble-process.big.exe
 # RUN: yaml2obj --docnum=2 %s > %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 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)
 # CHECK-NEXT: (lldb) disassemble --line
 # CHECK-NEXT: command-disassemble-process.exe`main:

 # CHECK-NEXT: ->  0x4004 <+2>: addb   %al, (%rdx)
 # CHECK-NEXT:     0x4006 <+4>: addb   %al, (%rbx)
 # CHECK-NEXT:     0x4008 <+6>: addb   %al, (%rsi)
 # CHECK-NEXT:     0x400a:      addb   %al, (%rdi)
 # CHECK-NEXT:     0x400c:      addb   %cl, (%rax)
 # CHECK-NEXT:     0x400e:      addb   %cl, (%rcx)
 # CHECK-NEXT:     0x4010:      addb   %cl, (%rdx)
 
+# BIG: error: Not disassembling the current function because it is very large [0x0000000000004002-0x0000000000004fa2). To disassemble specify an instruction count limit, start/stop addresses or use the --force option.
+
 --- !ELF
 FileHeader:      
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:        
   - Name:            .text
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Address:         0x0000000000004000
     AddressAlign:    0x0000000000001000
     Content:         00000001000200030006000700080009000A000B000E000F00100011001200130016001700180019001A001B001E001F00200021002200230026002700280029002A002B002E002F
+    Size:            0x10000
   - Name:            .note.gnu.build-id
     Type:            SHT_NOTE
     Flags:           [ SHF_ALLOC ]
     Address:         0x0000000000005000
     AddressAlign:    0x0000000000001000
     Content:         040000000800000003000000474E5500DEADBEEFBAADF00D
 Symbols:
   - Name:            main
     Type:            STT_FUNC
     Section:         .text
     Value:           0x0000000000004002
-    Size:            0x0000000000000008
+    Size:            [[MAIN_SIZE]]
 ProgramHeaders:
   - Type: PT_LOAD
     Flags: [ PF_X, PF_R ]
     VAddr: 0x4000
     Align: 0x1000
     Sections:
       - Section: .text
   - Type: PT_LOAD

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

 # CHECK-NEXT: command-disassemble.s.tmp`foo:
 # CHECK-NEXT: command-disassemble.s.tmp[0x0] <+0>:  int    $0x10
 # CHECK-NEXT: command-disassemble.s.tmp[0x2] <+2>:  int    $0x11
 # CHECK-NEXT: command-disassemble.s.tmp[0x4] <+4>:  int    $0x12
 # CHECK-NEXT: command-disassemble.s.tmp[0x6] <+6>:  int    $0x13
 # CHECK-NEXT: command-disassemble.s.tmp[0x8] <+8>:  int    $0x14
 # CHECK-NEXT: command-disassemble.s.tmp[0xa] <+10>: int    $0x15
 # CHECK-NEXT: command-disassemble.s.tmp[0xc] <+12>: int    $0x16
-# CHECK-NEXT: (lldb) disassemble --address 0xdead
-# CHECK-NEXT: error: Could not find function bounds for address 0xdead
+# CHECK-NEXT: (lldb) disassemble --address 0xdeadb
+# CHECK-NEXT: error: Could not find function bounds for address 0xdeadb
+# CHECK-NEXT: (lldb) disassemble --address 0x100
+# CHECK-NEXT: error: Not disassembling the function because it is very large [0x0000000000000040-0x0000000000002040). To disassemble specify an instruction count limit, start/stop addresses or use the --force option.
+# CHECK-NEXT: (lldb) disassemble --address 0x100 --count 3
+# CHECK-NEXT: command-disassemble.s.tmp`very_long:
+# CHECK-NEXT: command-disassemble.s.tmp[0x40] <+0>: int    $0x2a
+# CHECK-NEXT: command-disassemble.s.tmp[0x42] <+2>: int    $0x2a
+# CHECK-NEXT: command-disassemble.s.tmp[0x44] <+4>: int    $0x2a
+# CHECK-NEXT: (lldb) disassemble --address 0x100 --force
+# CHECK-NEXT: command-disassemble.s.tmp`very_long:
+# CHECK-NEXT: command-disassemble.s.tmp[0x40]   <+0>:    int    $0x2a
+# CHECK:      command-disassemble.s.tmp[0x203e] <+8190>: int    $0x2a
 # CHECK-NEXT: (lldb) disassemble --start-address 0x0 --count 7
 # CHECK-NEXT: command-disassemble.s.tmp`foo:
 # CHECK-NEXT: command-disassemble.s.tmp[0x0] <+0>:  int    $0x10
 # CHECK-NEXT: command-disassemble.s.tmp[0x2] <+2>:  int    $0x11
 # CHECK-NEXT: command-disassemble.s.tmp[0x4] <+4>:  int    $0x12
 # CHECK-NEXT: command-disassemble.s.tmp[0x6] <+6>:  int    $0x13
 # CHECK-NEXT: command-disassemble.s.tmp[0x8] <+8>:  int    $0x14
 # CHECK-NEXT: command-disassemble.s.tmp[0xa] <+10>: int    $0x15
 # CHECK-NEXT: command-disassemble.s.tmp[0xc] <+12>: int    $0x16
 # CHECK-NEXT: (lldb) disassemble --start-address 0x0 --end-address 0x20 --count 7
 # CHECK-NEXT: error: invalid combination of options for the given command
-# CHECK-NEXT: (lldb) disassemble --address 0x0 --count 7
-# CHECK-NEXT: error: invalid combination of options for the given command
+# CHECK-NEXT: (lldb) disassemble --name case1
+# CHECK-NEXT: command-disassemble.s.tmp`n1::case1:
+# CHECK-NEXT: command-disassemble.s.tmp[0x2040] <+0>: int    $0x30
+# CHECK-EMPTY:
+# CHECK-NEXT: command-disassemble.s.tmp`n2::case1:
+# CHECK-NEXT: command-disassemble.s.tmp[0x2042] <+0>: int    $0x31
+# CHECK-EMPTY:
+# CHECK-NEXT: (lldb) disassemble --name case2
+# CHECK-NEXT: command-disassemble.s.tmp`n1::case2:
+# CHECK-NEXT: command-disassemble.s.tmp[0x2044] <+0>: int    $0x32
+# CHECK-NEXT: warning: Not disassembling a range because it is very large [0x0000000000002046-0x0000000000004046). To disassemble specify an instruction count limit, start/stop addresses or use the --force option.
+# CHECK-NEXT: (lldb) disassemble --name case3
+# CHECK-NEXT: error: Not disassembling a range because it is very large [0x0000000000004046-0x0000000000006046). To disassemble specify an instruction count limit, start/stop addresses or use the --force option.
+# CHECK-NEXT: Not disassembling a range because it is very large [0x0000000000006046-0x0000000000008046). To disassemble specify an instruction count limit, start/stop addresses or use the --force option.
+# CHECK-NEXT: (lldb) disassemble --name case3 --count 3
+# CHECK-NEXT: command-disassemble.s.tmp`n1::case3:
+# CHECK-NEXT: command-disassemble.s.tmp[0x4046] <+0>: int    $0x2a
+# CHECK-NEXT: command-disassemble.s.tmp[0x4048] <+2>: int    $0x2a
+# CHECK-NEXT: command-disassemble.s.tmp[0x404a] <+4>: int    $0x2a
+# CHECK-EMPTY:
+# CHECK-NEXT: command-disassemble.s.tmp`n2::case3:
+# CHECK-NEXT: command-disassemble.s.tmp[0x6046] <+0>: int    $0x2a
+# CHECK-NEXT: command-disassemble.s.tmp[0x6048] <+2>: int    $0x2a
+# CHECK-NEXT: command-disassemble.s.tmp[0x604a] <+4>: int    $0x2a
+# CHECK-EMPTY:
+
 
         .text
 foo:
         int $0x10
         int $0x11
         int $0x12
         int $0x13
         int $0x14
bar:
         int $0x28
         int $0x29
         int $0x2a
         int $0x2b
         int $0x2c
         int $0x2d
         int $0x2e
         int $0x2f
+
+very_long:
+        .rept 0x1000
+        int $42
+        .endr
+
+_ZN2n15case1Ev:
+        int $0x30
+
+_ZN2n25case1Ev:
+        int $0x31
+
+_ZN2n15case2Ev:
+        int $0x32
+
+_ZN2n25case2Ev:
+        .rept 0x1000
+        int $42
+        .endr
+
+_ZN2n15case3Ev:
+        .rept 0x1000
+        int $42
+        .endr
+
+_ZN2n25case3Ev:
+        .rept 0x1000
+        int $42
+        .endr