Merge GDB 7.5.1

gdb/disasm.c

 /* Disassemble support for GDB.
 
    Copyright (C) 2000-2005, 2007-2012 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
@@ skipping 79 matching lines @@
       if (val == 0)
         val = mle1->start_pc - mle2->start_pc;
     }
   return val;
 }
 
 static int
 dump_insns (struct gdbarch *gdbarch, struct ui_out *uiout,
             struct disassemble_info * di,
             CORE_ADDR low, CORE_ADDR high,
-            int how_many, int flags, struct ui_stream *stb)
+            int how_many, int flags, struct ui_file *stb)
 {
   int num_displayed = 0;
   CORE_ADDR pc;
 
   /* parts of the symbolic representation of the address */
   int unmapped;
   int offset;
   int line;
   struct cleanup *ui_out_chain;
 
@@ skipping 27 matching lines @@
           ui_out_text (uiout, ">:\t");
         }
       else
         ui_out_text (uiout, ":\t");
 
       if (filename != NULL)
         xfree (filename);
       if (name != NULL)
         xfree (name);
 
-      ui_file_rewind (stb->stream);
+      ui_file_rewind (stb);
       if (flags & DISASSEMBLY_RAW_INSN)
         {
           CORE_ADDR old_pc = pc;
           bfd_byte data;
           int status;
           const char *spacer = "";
 
           /* Build the opcodes using a temporary stream so we can
              write them out in a single go for the MI.  */
-          struct ui_stream *opcode_stream = ui_out_stream_new (uiout);
+          struct ui_file *opcode_stream = mem_fileopen ();
           struct cleanup *cleanups =
-            make_cleanup_ui_out_stream_delete (opcode_stream);
+            make_cleanup_ui_file_delete (opcode_stream);
 
           pc += gdbarch_print_insn (gdbarch, pc, di);
           for (;old_pc < pc; old_pc++)
             {
               status = (*di->read_memory_func) (old_pc, &data, 1, di);
               if (status != 0)
                 (*di->memory_error_func) (status, old_pc, di);
-              fprintf_filtered (opcode_stream->stream, "%s%02x",
+              fprintf_filtered (opcode_stream, "%s%02x",
                                 spacer, (unsigned) data);
               spacer = " ";
             }
           ui_out_field_stream (uiout, "opcodes", opcode_stream);
           ui_out_text (uiout, "\t");
 
           do_cleanups (cleanups);
         }
       else
         pc += gdbarch_print_insn (gdbarch, pc, di);
       ui_out_field_stream (uiout, "inst", stb);
-      ui_file_rewind (stb->stream);
+      ui_file_rewind (stb);
       do_cleanups (ui_out_chain);
       ui_out_text (uiout, "\n");
     }
   return num_displayed;
 }
 
 /* The idea here is to present a source-O-centric view of a
    function to the user.  This means that things are presented
    in source order, with (possibly) out of order assembly
    immediately following.  */
 
 static void
 do_mixed_source_and_assembly (struct gdbarch *gdbarch, struct ui_out *uiout,
                               struct disassemble_info *di, int nlines,
                               struct linetable_entry *le,
                               CORE_ADDR low, CORE_ADDR high,
                               struct symtab *symtab,
-                              int how_many, int flags, struct ui_stream *stb)
+                              int how_many, int flags, struct ui_file *stb)
 {
   int newlines = 0;
   struct dis_line_entry *mle;
   struct symtab_and_line sal;
   int i;
   int out_of_order = 0;
   int next_line = 0;
   int num_displayed = 0;
   struct cleanup *ui_out_chain;
   struct cleanup *ui_out_tuple_chain = make_cleanup (null_cleanup, 0);
@@ skipping 126 matching lines @@
         break;
     }
   do_cleanups (ui_out_chain);
 }
 
 
 static void
 do_assembly_only (struct gdbarch *gdbarch, struct ui_out *uiout,
                   struct disassemble_info * di,
                   CORE_ADDR low, CORE_ADDR high,
-                  int how_many, int flags, struct ui_stream *stb)
+                  int how_many, int flags, struct ui_file *stb)
 {
   int num_displayed = 0;
   struct cleanup *ui_out_chain;
 
   ui_out_chain = make_cleanup_ui_out_list_begin_end (uiout, "asm_insns");
 
   num_displayed = dump_insns (gdbarch, uiout, di, low, high, how_many,
                               flags, stb);
 
   do_cleanups (ui_out_chain);
@@ skipping 39 matching lines @@
   di.application_data = gdbarch;
   disassemble_init_for_target (&di);
   return di;
 }
 
 void
 gdb_disassembly (struct gdbarch *gdbarch, struct ui_out *uiout,
                  char *file_string, int flags, int how_many,
                  CORE_ADDR low, CORE_ADDR high)
 {
-  struct ui_stream *stb = ui_out_stream_new (uiout);
-  struct cleanup *cleanups = make_cleanup_ui_out_stream_delete (stb);
-  struct disassemble_info di = gdb_disassemble_info (gdbarch, stb->stream);
+  struct ui_file *stb = mem_fileopen ();
+  struct cleanup *cleanups = make_cleanup_ui_file_delete (stb);
+  struct disassemble_info di = gdb_disassemble_info (gdbarch, stb);
   /* To collect the instruction outputted from opcodes.  */
   struct symtab *symtab = NULL;
   struct linetable_entry *le = NULL;
   int nlines = -1;
 
   /* Assume symtab is valid for whole PC range.  */
   symtab = find_pc_symtab (low);
 
   if (symtab != NULL && symtab->linetable != NULL)
     {
@@ skipping 102 matching lines @@
 int
 gdb_buffered_insn_length (struct gdbarch *gdbarch,
                           const gdb_byte *insn, int max_len, CORE_ADDR addr)
 {
   struct disassemble_info di;
 
   gdb_buffered_insn_length_init_dis (gdbarch, &di, insn, max_len, addr);
 
   return gdbarch_print_insn (gdbarch, addr, &di);
 }