* dwarf2-frame.c (struct dwarf2_cie): Make initial_instructions, end

	"const gdb_byte *".
	(struct dwarf2_fde): Make instructions, end "const gdb_byte *".
	(execute_cfa_program): Update to match API of leb128 functions.
	(read_1_byte, read_4_bytes, read_8_bytes): Make buf parameter
	"const gdb_byte *".
	(read_unsigned_leb128, read_signed_leb128): Delete.
	(read_initial_length): Change type of buf argument to
	"const gdb_byte *".
	(read_encoded_value): Update to match API of leb128 functions.
	(decode_frame_entry): Change result to "const gdb_byte *", and
	similarly for "start" parameter.
	(decode_frame_entry_1): Ditto.  Use new leb128 reader functions.
	(dwarf2_build_frame_info): Change local frame_ptr to
	"const gdb_byte *".
	* dwarf2expr.c (safe_read_uleb128, safe_read_sleb128): Replaces
	read_uleb128, read_sleb128.  All callers updated.
	(safe_skip_leb128): New function.
	(dwarf_block_to_dwarf_reg): Update to match API of leb128 functions.
	Call gdb_read_uleb128, gdb_skip_leb128 instead of read_uleb128.
	(dwarf_block_to_dwarf_reg_deref): Update to match API of leb128
	functions.  Call gdb_read_uleb128, gdb_read_sleb128 instead of
	read_uleb128, read_sleb128.
	(dwarf_block_to_fb_offset, dwarf_block_to_sp_offset): Ditto.
	(execute_stack_op): Update to match API of leb128 functions.
	* dwarf2expr.h: #include "leb128.h".
	(read_uleb128, read_sleb128): Delete.
	(gdb_read_uleb128, gdb_read_sleb128, gdb_skip_leb128): New functions.
	(safe_read_uleb128, safe_read_sleb128, safe_skip_leb128): Declare.
	* dwarf2loc.c (debug_loc_kind): New enum.
	(decode_debug_loc_addresses): New function.
	(decode_debug_loc_dwo_addresses): New function.
	(dwarf2_find_location_expression): Rewrite.
	(dwarf2_compile_expr_to_ax): Update to match API of leb128 functions.
	(locexpr_describe_location_piece): Ditto.
	(disassemble_dwarf_expression): Ditto.
	(locexpr_describe_location_1): Ditto.
	(loclist_describe_location): Rewrite.
	* dwarf2loc.h (dwarf2_loclist_baton): New member "from_dwo".
	* dwarf2read.c (die_reader_specs): New member "buffer_end".
	(dwarf2_section_buffer_overflow_complaint): Renamed from
	dwarf2_macros_too_long_complaint.  All callers updated.
	(skip_leb128): Delete.
	(init_cu_die_reader): Initialize reader->buffer_end.
	(skip_one_die): Replace call to skip_leb128 with safe_skip_leb128.
	(skip_form_bytes): New arg buffer_end.  All callers updated.
	Replace call to skip_leb128 with gdb_skip_leb128.
	(skip_unknown_opcode): New arg mac_end.  All callers updated.
	(fill_in_loclist_baton): Initialize baton->from_dwo.

7 files changed, 530 insertions, 366 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 90cc26c3390..98ffd2f5fea 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,55 @@
+2012-05-22  Doug Evans  <dje@google.com>
+
+	* dwarf2-frame.c (struct dwarf2_cie): Make initial_instructions, end
+	"const gdb_byte *".
+	(struct dwarf2_fde): Make instructions, end "const gdb_byte *".
+	(execute_cfa_program): Update to match API of leb128 functions.
+	(read_1_byte, read_4_bytes, read_8_bytes): Make buf parameter
+	"const gdb_byte *".
+	(read_unsigned_leb128, read_signed_leb128): Delete.
+	(read_initial_length): Change type of buf argument to
+	"const gdb_byte *".
+	(read_encoded_value): Update to match API of leb128 functions.
+	(decode_frame_entry): Change result to "const gdb_byte *", and
+	similarly for "start" parameter.
+	(decode_frame_entry_1): Ditto.  Use new leb128 reader functions.
+	(dwarf2_build_frame_info): Change local frame_ptr to
+	"const gdb_byte *".
+	* dwarf2expr.c (safe_read_uleb128, safe_read_sleb128): Replaces
+	read_uleb128, read_sleb128.  All callers updated.
+	(safe_skip_leb128): New function.
+	(dwarf_block_to_dwarf_reg): Update to match API of leb128 functions.
+	Call gdb_read_uleb128, gdb_skip_leb128 instead of read_uleb128.
+	(dwarf_block_to_dwarf_reg_deref): Update to match API of leb128
+	functions.  Call gdb_read_uleb128, gdb_read_sleb128 instead of
+	read_uleb128, read_sleb128.
+	(dwarf_block_to_fb_offset, dwarf_block_to_sp_offset): Ditto.
+	(execute_stack_op): Update to match API of leb128 functions.
+	* dwarf2expr.h: #include "leb128.h".
+	(read_uleb128, read_sleb128): Delete.
+	(gdb_read_uleb128, gdb_read_sleb128, gdb_skip_leb128): New functions.
+	(safe_read_uleb128, safe_read_sleb128, safe_skip_leb128): Declare.
+	* dwarf2loc.c (debug_loc_kind): New enum.
+	(decode_debug_loc_addresses): New function.
+	(decode_debug_loc_dwo_addresses): New function.
+	(dwarf2_find_location_expression): Rewrite.
+	(dwarf2_compile_expr_to_ax): Update to match API of leb128 functions.
+	(locexpr_describe_location_piece): Ditto.
+	(disassemble_dwarf_expression): Ditto.
+	(locexpr_describe_location_1): Ditto.
+	(loclist_describe_location): Rewrite.
+	* dwarf2loc.h (dwarf2_loclist_baton): New member "from_dwo".
+	* dwarf2read.c (die_reader_specs): New member "buffer_end".
+	(dwarf2_section_buffer_overflow_complaint): Renamed from
+	dwarf2_macros_too_long_complaint.  All callers updated.
+	(skip_leb128): Delete.
+	(init_cu_die_reader): Initialize reader->buffer_end.
+	(skip_one_die): Replace call to skip_leb128 with safe_skip_leb128.
+	(skip_form_bytes): New arg buffer_end.  All callers updated.
+	Replace call to skip_leb128 with gdb_skip_leb128.
+	(skip_unknown_opcode): New arg mac_end.  All callers updated.
+	(fill_in_loclist_baton): Initialize baton->from_dwo.
+
 2012-05-22  Maciej W. Rozycki  <macro@codesourcery.com>
 
 	* mips-linux-nat.c (mips_linux_read_description): Use a more
diff --git a/gdb/dwarf2-frame.c b/gdb/dwarf2-frame.c
index 670e26f2de9..96fa4516a65 100644
--- a/gdb/dwarf2-frame.c
+++ b/gdb/dwarf2-frame.c
@@ -68,8 +68,8 @@ struct dwarf2_cie
   ULONGEST return_address_register;
 
   /* Instruction sequence to initialize a register set.  */
-  gdb_byte *initial_instructions;
-  gdb_byte *end;
+  const gdb_byte *initial_instructions;
+  const gdb_byte *end;
 
   /* Saved augmentation, in case it's needed later.  */
   char *augmentation;
@@ -116,8 +116,8 @@ struct dwarf2_fde
   CORE_ADDR address_range;
 
   /* Instruction sequence.  */
-  gdb_byte *instructions;
-  gdb_byte *end;
+  const gdb_byte *instructions;
+  const gdb_byte *end;
 
   /* True if this FDE is read from a .eh_frame instead of a .debug_frame
      section.  */
@@ -416,8 +416,8 @@ execute_cfa_program (struct dwarf2_fde *fde, const gdb_byte *insn_ptr,
   while (insn_ptr < insn_end && fs->pc <= pc)
     {
       gdb_byte insn = *insn_ptr++;
-      ULONGEST utmp, reg;
-      LONGEST offset;
+      unsigned long long utmp, reg;
+      long long offset;
 
       if ((insn & 0xc0) == DW_CFA_advance_loc)
 	fs->pc += (insn & 0x3f) * fs->code_align;
@@ -425,7 +425,7 @@ execute_cfa_program (struct dwarf2_fde *fde, const gdb_byte *insn_ptr,
 	{
 	  reg = insn & 0x3f;
 	  reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
-	  insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
+	  insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
 	  offset = utmp * fs->data_align;
 	  dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 	  fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
@@ -467,9 +467,9 @@ execute_cfa_program (struct dwarf2_fde *fde, const gdb_byte *insn_ptr,
 	      break;
 
 	    case DW_CFA_offset_extended:
-	      insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
+	      insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &reg);
 	      reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
-	      insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
+	      insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
 	      offset = utmp * fs->data_align;
 	      dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 	      fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
@@ -477,28 +477,28 @@ execute_cfa_program (struct dwarf2_fde *fde, const gdb_byte *insn_ptr,
 	      break;
 
 	    case DW_CFA_restore_extended:
-	      insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
+	      insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &reg);
 	      dwarf2_restore_rule (gdbarch, reg, fs, eh_frame_p);
 	      break;
 
 	    case DW_CFA_undefined:
-	      insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
+	      insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &reg);
 	      reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
 	      dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 	      fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNDEFINED;
 	      break;
 
 	    case DW_CFA_same_value:
-	      insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
+	      insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &reg);
 	      reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
 	      dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 	      fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAME_VALUE;
 	      break;
 
 	    case DW_CFA_register:
-	      insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
+	      insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &reg);
 	      reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
-	      insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
+	      insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
 	      utmp = dwarf2_frame_adjust_regnum (gdbarch, utmp, eh_frame_p);
 	      dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 	      fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
@@ -536,8 +536,9 @@ bad CFI data; mismatched DW_CFA_restore_state at %s"),
 	      break;
 
 	    case DW_CFA_def_cfa:
-	      insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->regs.cfa_reg);
-	      insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
+	      insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &reg);
+	      fs->regs.cfa_reg = reg;
+	      insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
 
 	      if (fs->armcc_cfa_offsets_sf)
 		utmp *= fs->data_align;
@@ -547,15 +548,14 @@ bad CFI data; mismatched DW_CFA_restore_state at %s"),
 	      break;
 
 	    case DW_CFA_def_cfa_register:
-	      insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->regs.cfa_reg);
-	      fs->regs.cfa_reg = dwarf2_frame_adjust_regnum (gdbarch,
-                                                             fs->regs.cfa_reg,
+	      insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &reg);
+	      fs->regs.cfa_reg = dwarf2_frame_adjust_regnum (gdbarch, reg,
                                                              eh_frame_p);
 	      fs->regs.cfa_how = CFA_REG_OFFSET;
 	      break;
 
 	    case DW_CFA_def_cfa_offset:
-	      insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
+	      insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
 
 	      if (fs->armcc_cfa_offsets_sf)
 		utmp *= fs->data_align;
@@ -568,18 +568,18 @@ bad CFI data; mismatched DW_CFA_restore_state at %s"),
 	      break;
 
 	    case DW_CFA_def_cfa_expression:
-	      insn_ptr = read_uleb128 (insn_ptr, insn_end,
-                                       &fs->regs.cfa_exp_len);
+	      insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
+	      fs->regs.cfa_exp_len = utmp;
 	      fs->regs.cfa_exp = insn_ptr;
 	      fs->regs.cfa_how = CFA_EXP;
 	      insn_ptr += fs->regs.cfa_exp_len;
 	      break;
 
 	    case DW_CFA_expression:
-	      insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
+	      insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &reg);
 	      reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
 	      dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
-	      insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
+	      insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
 	      fs->regs.reg[reg].loc.exp = insn_ptr;
 	      fs->regs.reg[reg].exp_len = utmp;
 	      fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_EXP;
@@ -587,9 +587,9 @@ bad CFI data; mismatched DW_CFA_restore_state at %s"),
 	      break;
 
 	    case DW_CFA_offset_extended_sf:
-	      insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
+	      insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &reg);
 	      reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
-	      insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
+	      insn_ptr = safe_read_sleb128 (insn_ptr, insn_end, &offset);
 	      offset *= fs->data_align;
 	      dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 	      fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
@@ -597,27 +597,27 @@ bad CFI data; mismatched DW_CFA_restore_state at %s"),
 	      break;
 
 	    case DW_CFA_val_offset:
-	      insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
+	      insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &reg);
 	      dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
-	      insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
+	      insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
 	      offset = utmp * fs->data_align;
 	      fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
 	      fs->regs.reg[reg].loc.offset = offset;
 	      break;
 
 	    case DW_CFA_val_offset_sf:
-	      insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
+	      insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &reg);
 	      dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
-	      insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
+	      insn_ptr = safe_read_sleb128 (insn_ptr, insn_end, &offset);
 	      offset *= fs->data_align;
 	      fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
 	      fs->regs.reg[reg].loc.offset = offset;
 	      break;
 
 	    case DW_CFA_val_expression:
-	      insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
+	      insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &reg);
 	      dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
-	      insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
+	      insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
 	      fs->regs.reg[reg].loc.exp = insn_ptr;
 	      fs->regs.reg[reg].exp_len = utmp;
 	      fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_EXP;
@@ -625,17 +625,16 @@ bad CFI data; mismatched DW_CFA_restore_state at %s"),
 	      break;
 
 	    case DW_CFA_def_cfa_sf:
-	      insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->regs.cfa_reg);
-	      fs->regs.cfa_reg = dwarf2_frame_adjust_regnum (gdbarch,
-                                                             fs->regs.cfa_reg,
+	      insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &reg);
+	      fs->regs.cfa_reg = dwarf2_frame_adjust_regnum (gdbarch, reg,
                                                              eh_frame_p);
-	      insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
+	      insn_ptr = safe_read_sleb128 (insn_ptr, insn_end, &offset);
 	      fs->regs.cfa_offset = offset * fs->data_align;
 	      fs->regs.cfa_how = CFA_REG_OFFSET;
 	      break;
 
 	    case DW_CFA_def_cfa_offset_sf:
-	      insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
+	      insn_ptr = safe_read_sleb128 (insn_ptr, insn_end, &offset);
 	      fs->regs.cfa_offset = offset * fs->data_align;
 	      /* cfa_how deliberately not set.  */
 	      break;
@@ -667,13 +666,13 @@ bad CFI data; mismatched DW_CFA_restore_state at %s"),
 
 	    case DW_CFA_GNU_args_size:
 	      /* Ignored.  */
-	      insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
+	      insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
 	      break;
 
 	    case DW_CFA_GNU_negative_offset_extended:
-	      insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
+	      insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &reg);
 	      reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
-	      insn_ptr = read_uleb128 (insn_ptr, insn_end, &offset);
+	      insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &offset);
 	      offset *= fs->data_align;
 	      dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 	      fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
@@ -1501,82 +1500,26 @@ dwarf2_frame_cfa (struct frame_info *this_frame)
 const struct objfile_data *dwarf2_frame_objfile_data;
 
 static unsigned int
-read_1_byte (bfd *abfd, gdb_byte *buf)
+read_1_byte (bfd *abfd, const gdb_byte *buf)
 {
   return bfd_get_8 (abfd, buf);
 }
 
 static unsigned int
-read_4_bytes (bfd *abfd, gdb_byte *buf)
+read_4_bytes (bfd *abfd, const gdb_byte *buf)
 {
   return bfd_get_32 (abfd, buf);
 }
 
 static ULONGEST
-read_8_bytes (bfd *abfd, gdb_byte *buf)
+read_8_bytes (bfd *abfd, const gdb_byte *buf)
 {
   return bfd_get_64 (abfd, buf);
 }
 
 static ULONGEST
-read_unsigned_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
-{
-  ULONGEST result;
-  unsigned int num_read;
-  int shift;
-  gdb_byte byte;
-
-  result = 0;
-  shift = 0;
-  num_read = 0;
-
-  do
-    {
-      byte = bfd_get_8 (abfd, (bfd_byte *) buf);
-      buf++;
-      num_read++;
-      result |= ((byte & 0x7f) << shift);
-      shift += 7;
-    }
-  while (byte & 0x80);
-
-  *bytes_read_ptr = num_read;
-
-  return result;
-}
-
-static LONGEST
-read_signed_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
-{
-  LONGEST result;
-  int shift;
-  unsigned int num_read;
-  gdb_byte byte;
-
-  result = 0;
-  shift = 0;
-  num_read = 0;
-
-  do
-    {
-      byte = bfd_get_8 (abfd, (bfd_byte *) buf);
-      buf++;
-      num_read++;
-      result |= ((byte & 0x7f) << shift);
-      shift += 7;
-    }
-  while (byte & 0x80);
-
-  if (shift < 8 * sizeof (result) && (byte & 0x40))
-    result |= -(((LONGEST)1) << shift);
-
-  *bytes_read_ptr = num_read;
-
-  return result;
-}
-
-static ULONGEST
-read_initial_length (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
+read_initial_length (bfd *abfd, const gdb_byte *buf,
+		     unsigned int *bytes_read_ptr)
 {
   LONGEST result;
 
@@ -1685,10 +1628,10 @@ read_encoded_value (struct comp_unit *unit, gdb_byte encoding,
     {
     case DW_EH_PE_uleb128:
       {
-	ULONGEST value;
+	unsigned long long value;
 	const gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
 
-	*bytes_read_ptr += read_uleb128 (buf, end_buf, &value) - buf;
+	*bytes_read_ptr += safe_read_uleb128 (buf, end_buf, &value) - buf;
 	return base + value;
       }
     case DW_EH_PE_udata2:
@@ -1702,10 +1645,10 @@ read_encoded_value (struct comp_unit *unit, gdb_byte encoding,
       return (base + bfd_get_64 (unit->abfd, (bfd_byte *) buf));
     case DW_EH_PE_sleb128:
       {
-	LONGEST value;
+	long long value;
 	const gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
 
-	*bytes_read_ptr += read_sleb128 (buf, end_buf, &value) - buf;
+	*bytes_read_ptr += safe_read_sleb128 (buf, end_buf, &value) - buf;
 	return base + value;
       }
     case DW_EH_PE_sdata2:
@@ -1863,28 +1806,32 @@ enum eh_frame_type
   EH_CIE_OR_FDE_TYPE_ID = EH_CIE_TYPE_ID | EH_FDE_TYPE_ID
 };
 
-static gdb_byte *decode_frame_entry (struct comp_unit *unit, gdb_byte *start,
-				     int eh_frame_p,
-                                     struct dwarf2_cie_table *cie_table,
-                                     struct dwarf2_fde_table *fde_table,
-                                     enum eh_frame_type entry_type);
+static const gdb_byte *decode_frame_entry (struct comp_unit *unit,
+					   const gdb_byte *start,
+					   int eh_frame_p,
+					   struct dwarf2_cie_table *cie_table,
+					   struct dwarf2_fde_table *fde_table,
+					   enum eh_frame_type entry_type);
 
 /* Decode the next CIE or FDE, entry_type specifies the expected type.
    Return NULL if invalid input, otherwise the next byte to be processed.  */
 
-static gdb_byte *
-decode_frame_entry_1 (struct comp_unit *unit, gdb_byte *start, int eh_frame_p,
+static const gdb_byte *
+decode_frame_entry_1 (struct comp_unit *unit, const gdb_byte *start,
+		      int eh_frame_p,
                       struct dwarf2_cie_table *cie_table,
                       struct dwarf2_fde_table *fde_table,
                       enum eh_frame_type entry_type)
 {
   struct gdbarch *gdbarch = get_objfile_arch (unit->objfile);
-  gdb_byte *buf, *end;
+  const gdb_byte *buf, *end;
   LONGEST length;
   unsigned int bytes_read;
   int dwarf64_p;
   ULONGEST cie_id;
   ULONGEST cie_pointer;
+  long long sleb128;
+  unsigned long long uleb128;
 
   buf = start;
   length = read_initial_length (unit->abfd, buf, &bytes_read);
@@ -2000,37 +1947,41 @@ decode_frame_entry_1 (struct comp_unit *unit, gdb_byte *start, int eh_frame_p,
       else
 	cie->ptr_size = cie->addr_size;
 
-      cie->code_alignment_factor =
-	read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
-      buf += bytes_read;
+      buf = gdb_read_uleb128 (buf, end, &uleb128);
+      if (buf == NULL)
+	return NULL;
+      cie->code_alignment_factor = uleb128;
 
-      cie->data_alignment_factor =
-	read_signed_leb128 (unit->abfd, buf, &bytes_read);
-      buf += bytes_read;
+      buf = gdb_read_sleb128 (buf, end, &sleb128);
+      if (buf == NULL)
+	return NULL;
+      cie->data_alignment_factor = sleb128;
 
       if (cie_version == 1)
 	{
 	  cie->return_address_register = read_1_byte (unit->abfd, buf);
-	  bytes_read = 1;
+	  ++buf;
 	}
       else
-	cie->return_address_register = read_unsigned_leb128 (unit->abfd, buf,
-							     &bytes_read);
+	{
+	  buf = gdb_read_uleb128 (buf, end, &uleb128);
+	  if (buf == NULL)
+	    return NULL;
+	  cie->return_address_register = uleb128;
+	}
+
       cie->return_address_register
 	= dwarf2_frame_adjust_regnum (gdbarch,
 				      cie->return_address_register,
 				      eh_frame_p);
 
-      buf += bytes_read;
-
       cie->saw_z_augmentation = (*augmentation == 'z');
       if (cie->saw_z_augmentation)
 	{
-	  ULONGEST length;
+	  unsigned long long length;
 
-	  length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
-	  buf += bytes_read;
-	  if (buf > end)
+	  buf = gdb_read_uleb128 (buf, end, &length);
+	  if (buf == NULL)
 	    return NULL;
 	  cie->initial_instructions = buf + length;
 	  augmentation++;
@@ -2144,10 +2095,12 @@ decode_frame_entry_1 (struct comp_unit *unit, gdb_byte *start, int eh_frame_p,
 	 can skip the whole thing.  */
       if (fde->cie->saw_z_augmentation)
 	{
-	  ULONGEST length;
+	  unsigned long long length;
 
-	  length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
-	  buf += bytes_read + length;
+	  buf = gdb_read_uleb128 (buf, end, &length);
+	  if (buf == NULL)
+	    return NULL;
+	  buf += length;
 	  if (buf > end)
 	    return NULL;
 	}
@@ -2166,14 +2119,15 @@ decode_frame_entry_1 (struct comp_unit *unit, gdb_byte *start, int eh_frame_p,
 /* Read a CIE or FDE in BUF and decode it. Entry_type specifies whether we
    expect an FDE or a CIE.  */
 
-static gdb_byte *
-decode_frame_entry (struct comp_unit *unit, gdb_byte *start, int eh_frame_p,
+static const gdb_byte *
+decode_frame_entry (struct comp_unit *unit, const gdb_byte *start,
+		    int eh_frame_p,
                     struct dwarf2_cie_table *cie_table,
                     struct dwarf2_fde_table *fde_table,
                     enum eh_frame_type entry_type)
 {
   enum { NONE, ALIGN4, ALIGN8, FAIL } workaround = NONE;
-  gdb_byte *ret;
+  const gdb_byte *ret;
   ptrdiff_t start_offset;
 
   while (1)
@@ -2285,7 +2239,7 @@ void
 dwarf2_build_frame_info (struct objfile *objfile)
 {
   struct comp_unit *unit;
-  gdb_byte *frame_ptr;
+  const gdb_byte *frame_ptr;
   struct dwarf2_cie_table cie_table;
   struct dwarf2_fde_table fde_table;
   struct dwarf2_fde_table *fde_table2;
diff --git a/gdb/dwarf2expr.c b/gdb/dwarf2expr.c
index 83d8e049832..80c6e173a31 100644
--- a/gdb/dwarf2expr.c
+++ b/gdb/dwarf2expr.c
@@ -369,60 +369,36 @@ dwarf_expr_eval (struct dwarf_expr_context *ctx, const gdb_byte *addr,
   gdb_assert (ctx->recursion_depth == old_recursion_depth);
 }
 
-/* Decode the unsigned LEB128 constant at BUF into the variable pointed to
-   by R, and return the new value of BUF.  Verify that it doesn't extend
-   past BUF_END.  R can be NULL, the constant is then only skipped.  */
+/* Helper to read a uleb128 value or throw an error.  */
 
 const gdb_byte *
-read_uleb128 (const gdb_byte *buf, const gdb_byte *buf_end, ULONGEST * r)
+safe_read_uleb128 (const gdb_byte *buf, const gdb_byte *buf_end,
+		   unsigned long long *r)
 {
-  unsigned shift = 0;
-  ULONGEST result = 0;
-  gdb_byte byte;
-
-  while (1)
-    {
-      if (buf >= buf_end)
-	error (_("read_uleb128: Corrupted DWARF expression."));
-
-      byte = *buf++;
-      result |= ((ULONGEST) (byte & 0x7f)) << shift;
-      if ((byte & 0x80) == 0)
-	break;
-      shift += 7;
-    }
-  if (r)
-    *r = result;
+  buf = gdb_read_uleb128 (buf, buf_end, r);
+  if (buf == NULL)
+    error (_("DWARF expression error: ran off end of buffer reading uleb128 value"));
   return buf;
 }
 
-/* Decode the signed LEB128 constant at BUF into the variable pointed to
-   by R, and return the new value of BUF.  Verify that it doesn't extend
-   past BUF_END.  R can be NULL, the constant is then only skipped.  */
+/* Helper to read a sleb128 value or throw an error.  */
 
 const gdb_byte *
-read_sleb128 (const gdb_byte *buf, const gdb_byte *buf_end, LONGEST * r)
+safe_read_sleb128 (const gdb_byte *buf, const gdb_byte *buf_end,
+		   long long *r)
 {
-  unsigned shift = 0;
-  LONGEST result = 0;
-  gdb_byte byte;
-
-  while (1)
-    {
-      if (buf >= buf_end)
-	error (_("read_sleb128: Corrupted DWARF expression."));
-
-      byte = *buf++;
-      result |= ((ULONGEST) (byte & 0x7f)) << shift;
-      shift += 7;
-      if ((byte & 0x80) == 0)
-	break;
-    }
-  if (shift < (sizeof (*r) * 8) && (byte & 0x40) != 0)
-    result |= -(((LONGEST) 1) << shift);
+  buf = gdb_read_sleb128 (buf, buf_end, r);
+  if (buf == NULL)
+    error (_("DWARF expression error: ran off end of buffer reading sleb128 value"));
+  return buf;
+}
 
-  if (r)
-    *r = result;
+const gdb_byte *
+safe_skip_leb128 (const gdb_byte *buf, const gdb_byte *buf_end)
+{
+  buf = gdb_skip_leb128 (buf, buf_end);
+  if (buf == NULL)
+    error (_("DWARF expression error: ran off end of buffer reading leb128 value"));
   return buf;
 }
 
@@ -489,7 +465,7 @@ dwarf_get_base_type (struct dwarf_expr_context *ctx, cu_offset die, int size)
 int
 dwarf_block_to_dwarf_reg (const gdb_byte *buf, const gdb_byte *buf_end)
 {
-  ULONGEST dwarf_reg;
+  unsigned long long dwarf_reg;
 
   if (buf_end <= buf)
     return -1;
@@ -503,13 +479,19 @@ dwarf_block_to_dwarf_reg (const gdb_byte *buf, const gdb_byte *buf_end)
   if (*buf == DW_OP_GNU_regval_type)
     {
       buf++;
-      buf = read_uleb128 (buf, buf_end, &dwarf_reg);
-      buf = read_uleb128 (buf, buf_end, NULL);
+      buf = gdb_read_uleb128 (buf, buf_end, &dwarf_reg);
+      if (buf == NULL)
+	return -1;
+      buf = gdb_skip_leb128 (buf, buf_end);
+      if (buf == NULL)
+	return -1;
     }
   else if (*buf == DW_OP_regx)
     {
       buf++;
-      buf = read_uleb128 (buf, buf_end, &dwarf_reg);
+      buf = gdb_read_uleb128 (buf, buf_end, &dwarf_reg);
+      if (buf == NULL)
+	return -1;
     }
   else
     return -1;
@@ -527,31 +509,35 @@ int
 dwarf_block_to_dwarf_reg_deref (const gdb_byte *buf, const gdb_byte *buf_end,
 				CORE_ADDR *deref_size_return)
 {
-  ULONGEST dwarf_reg;
-  LONGEST offset;
+  unsigned long long dwarf_reg;
+  long long offset;
 
   if (buf_end <= buf)
     return -1;
+
   if (*buf >= DW_OP_breg0 && *buf <= DW_OP_breg31)
     {
       dwarf_reg = *buf - DW_OP_breg0;
       buf++;
+      if (buf >= buf_end)
+	return -1;
     }
   else if (*buf == DW_OP_bregx)
     {
       buf++;
-      buf = read_uleb128 (buf, buf_end, &dwarf_reg);
+      buf = gdb_read_uleb128 (buf, buf_end, &dwarf_reg);
+      if (buf == NULL)
+	return -1;
       if ((int) dwarf_reg != dwarf_reg)
        return -1;
     }
   else
     return -1;
 
-  buf = read_sleb128 (buf, buf_end, &offset);
-  if (offset != 0)
+  buf = gdb_read_sleb128 (buf, buf_end, &offset);
+  if (buf == NULL)
     return -1;
-
-  if (buf >= buf_end)
+  if (offset != 0)
     return -1;
 
   if (*buf == DW_OP_deref)
@@ -582,7 +568,7 @@ int
 dwarf_block_to_fb_offset (const gdb_byte *buf, const gdb_byte *buf_end,
 			  CORE_ADDR *fb_offset_return)
 {
-  LONGEST fb_offset;
+  long long fb_offset;
 
   if (buf_end <= buf)
     return 0;
@@ -591,7 +577,9 @@ dwarf_block_to_fb_offset (const gdb_byte *buf, const gdb_byte *buf_end,
     return 0;
   buf++;
 
-  buf = read_sleb128 (buf, buf_end, &fb_offset);
+  buf = gdb_read_sleb128 (buf, buf_end, &fb_offset);
+  if (buf == NULL)
+    return 0;
   *fb_offset_return = fb_offset;
   if (buf != buf_end || fb_offset != (LONGEST) *fb_offset_return)
     return 0;
@@ -607,8 +595,8 @@ int
 dwarf_block_to_sp_offset (struct gdbarch *gdbarch, const gdb_byte *buf,
 			  const gdb_byte *buf_end, CORE_ADDR *sp_offset_return)
 {
-  ULONGEST dwarf_reg;
-  LONGEST sp_offset;
+  unsigned long long dwarf_reg;
+  long long sp_offset;
 
   if (buf_end <= buf)
     return 0;
@@ -622,14 +610,18 @@ dwarf_block_to_sp_offset (struct gdbarch *gdbarch, const gdb_byte *buf,
       if (*buf != DW_OP_bregx)
        return 0;
       buf++;
-      buf = read_uleb128 (buf, buf_end, &dwarf_reg);
+      buf = gdb_read_uleb128 (buf, buf_end, &dwarf_reg);
+      if (buf == NULL)
+	return 0;
     }
 
   if (gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_reg)
       != gdbarch_sp_regnum (gdbarch))
     return 0;
 
-  buf = read_sleb128 (buf, buf_end, &sp_offset);
+  buf = gdb_read_sleb128 (buf, buf_end, &sp_offset);
+  if (buf == NULL)
+    return 0;
   *sp_offset_return = sp_offset;
   if (buf != buf_end || sp_offset != (LONGEST) *sp_offset_return)
     return 0;
@@ -673,8 +665,8 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 	 This is just an optimization, so it's always ok to punt
 	 and leave this as 0.  */
       int in_stack_memory = 0;
-      ULONGEST uoffset, reg;
-      LONGEST offset;
+      unsigned long long uoffset, reg;
+      long long offset;
       struct value *result_val = NULL;
 
       /* The DWARF expression might have a bug causing an infinite
@@ -733,7 +725,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 	  break;
 
 	case DW_OP_GNU_addr_index:
-	  op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
+	  op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
 	  result = (ctx->funcs->get_addr_index) (ctx->baton, uoffset);
 	  result_val = value_from_ulongest (address_type, result);
 	  break;
@@ -779,12 +771,12 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 	  op_ptr += 8;
 	  break;
 	case DW_OP_constu:
-	  op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
+	  op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
 	  result = uoffset;
 	  result_val = value_from_ulongest (address_type, result);
 	  break;
 	case DW_OP_consts:
-	  op_ptr = read_sleb128 (op_ptr, op_end, &offset);
+	  op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
 	  result = offset;
 	  result_val = value_from_ulongest (address_type, result);
 	  break;
@@ -837,7 +829,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 	  break;
 
 	case DW_OP_regx:
-	  op_ptr = read_uleb128 (op_ptr, op_end, &reg);
+	  op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
 	  dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
 
 	  result = reg;
@@ -847,9 +839,9 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 
 	case DW_OP_implicit_value:
 	  {
-	    ULONGEST len;
+	    unsigned long long len;
 
-	    op_ptr = read_uleb128 (op_ptr, op_end, &len);
+	    op_ptr = safe_read_uleb128 (op_ptr, op_end, &len);
 	    if (op_ptr + len > op_end)
 	      error (_("DW_OP_implicit_value: too few bytes available."));
 	    ctx->len = len;
@@ -868,7 +860,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 
 	case DW_OP_GNU_implicit_pointer:
 	  {
-	    LONGEST len;
+	    long long len;
 
 	    if (ctx->ref_addr_size == -1)
 	      error (_("DWARF-2 expression error: DW_OP_GNU_implicit_pointer "
@@ -880,7 +872,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 	    op_ptr += ctx->ref_addr_size;
 
 	    /* The byte offset into the data.  */
-	    op_ptr = read_sleb128 (op_ptr, op_end, &len);
+	    op_ptr = safe_read_sleb128 (op_ptr, op_end, &len);
 	    result = (ULONGEST) len;
 	    result_val = value_from_ulongest (address_type, result);
 
@@ -923,7 +915,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 	case DW_OP_breg30:
 	case DW_OP_breg31:
 	  {
-	    op_ptr = read_sleb128 (op_ptr, op_end, &offset);
+	    op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
 	    result = (ctx->funcs->read_reg) (ctx->baton, op - DW_OP_breg0);
 	    result += offset;
 	    result_val = value_from_ulongest (address_type, result);
@@ -931,8 +923,8 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 	  break;
 	case DW_OP_bregx:
 	  {
-	    op_ptr = read_uleb128 (op_ptr, op_end, &reg);
-	    op_ptr = read_sleb128 (op_ptr, op_end, &offset);
+	    op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
+	    op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
 	    result = (ctx->funcs->read_reg) (ctx->baton, reg);
 	    result += offset;
 	    result_val = value_from_ulongest (address_type, result);
@@ -944,7 +936,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 	    size_t datalen;
 	    unsigned int before_stack_len;
 
-	    op_ptr = read_sleb128 (op_ptr, op_end, &offset);
+	    op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
 	    /* Rather than create a whole new context, we simply
 	       record the stack length before execution, then reset it
 	       afterwards, effectively erasing whatever the recursive
@@ -1038,7 +1030,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 	      {
 		cu_offset type_die;
 
-		op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
+		op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
 		type_die.cu_off = uoffset;
 		type = dwarf_get_base_type (ctx, type_die, 0);
 	      }
@@ -1089,7 +1081,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 	      case DW_OP_plus_uconst:
 		dwarf_require_integral (value_type (result_val));
 		result = value_as_long (result_val);
-		op_ptr = read_uleb128 (op_ptr, op_end, &reg);
+		op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
 		result += reg;
 		result_val = value_from_ulongest (address_type, result);
 		break;
@@ -1299,10 +1291,10 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 
         case DW_OP_piece:
           {
-            ULONGEST size;
+            unsigned long long size;
 
             /* Record the piece.  */
-            op_ptr = read_uleb128 (op_ptr, op_end, &size);
+            op_ptr = safe_read_uleb128 (op_ptr, op_end, &size);
 	    add_piece (ctx, 8 * size, 0);
 
             /* Pop off the address/regnum, and reset the location
@@ -1316,11 +1308,11 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 
 	case DW_OP_bit_piece:
 	  {
-	    ULONGEST size, offset;
+	    unsigned long long size, offset;
 
             /* Record the piece.  */
-	    op_ptr = read_uleb128 (op_ptr, op_end, &size);
-	    op_ptr = read_uleb128 (op_ptr, op_end, &offset);
+	    op_ptr = safe_read_uleb128 (op_ptr, op_end, &size);
+	    op_ptr = safe_read_uleb128 (op_ptr, op_end, &offset);
 	    add_piece (ctx, size, offset);
 
             /* Pop off the address/regnum, and reset the location
@@ -1362,11 +1354,11 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 	
 	case DW_OP_GNU_entry_value:
 	  {
-	    ULONGEST len;
+	    unsigned long long len;
 	    int dwarf_reg;
 	    CORE_ADDR deref_size;
 
-	    op_ptr = read_uleb128 (op_ptr, op_end, &len);
+	    op_ptr = safe_read_uleb128 (op_ptr, op_end, &len);
 	    if (op_ptr + len > op_end)
 	      error (_("DW_OP_GNU_entry_value: too few bytes available."));
 
@@ -1405,7 +1397,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 	    const gdb_byte *data;
 	    struct type *type;
 
-	    op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
+	    op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
 	    type_die.cu_off = uoffset;
 	    n = *op_ptr++;
 	    data = op_ptr;
@@ -1421,8 +1413,8 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 	    cu_offset type_die;
 	    struct type *type;
 
-	    op_ptr = read_uleb128 (op_ptr, op_end, &reg);
-	    op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
+	    op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
+	    op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
 	    type_die.cu_off = uoffset;
 
 	    type = dwarf_get_base_type (ctx, type_die, 0);
@@ -1439,7 +1431,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
 	    cu_offset type_die;
 	    struct type *type;
 
-	    op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
+	    op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
 	    type_die.cu_off = uoffset;
 
 	    if (type_die.cu_off == 0)
diff --git a/gdb/dwarf2expr.h b/gdb/dwarf2expr.h
index 3699dbbe63a..82a5a93e105 100644
--- a/gdb/dwarf2expr.h
+++ b/gdb/dwarf2expr.h
@@ -23,6 +23,8 @@
 #if !defined (DWARF2EXPR_H)
 #define DWARF2EXPR_H
 
+#include "leb128.h"
+
 struct dwarf_expr_context;
 
 /* Offset relative to the start of its containing CU (compilation unit).  */
@@ -273,12 +275,6 @@ struct value *dwarf_expr_fetch (struct dwarf_expr_context *ctx, int n);
 CORE_ADDR dwarf_expr_fetch_address (struct dwarf_expr_context *ctx, int n);
 int dwarf_expr_fetch_in_stack_memory (struct dwarf_expr_context *ctx, int n);
 
-
-const gdb_byte *read_uleb128 (const gdb_byte *buf, const gdb_byte *buf_end,
-			      ULONGEST * r);
-const gdb_byte *read_sleb128 (const gdb_byte *buf, const gdb_byte *buf_end,
-			      LONGEST * r);
-
 void dwarf_expr_require_composition (const gdb_byte *, const gdb_byte *,
 				     const char *);
 
@@ -310,4 +306,50 @@ int dwarf_block_to_sp_offset (struct gdbarch *gdbarch, const gdb_byte *buf,
 			      const gdb_byte *buf_end,
 			      CORE_ADDR *sp_offset_return);
 
+/* Wrappers around the leb128 reader routines to simplify them for our
+   purposes.  */
+
+static inline const gdb_byte *
+gdb_read_uleb128 (const gdb_byte *buf, const gdb_byte *buf_end,
+		  unsigned long long *r)
+{
+  size_t bytes_read = read_uleb128_to_ull (buf, buf_end, r);
+
+  if (bytes_read == 0)
+    return NULL;
+  return buf + bytes_read;
+}
+
+static inline const gdb_byte *
+gdb_read_sleb128 (const gdb_byte *buf, const gdb_byte *buf_end,
+		  long long *r)
+{
+  size_t bytes_read = read_sleb128_to_ll (buf, buf_end, r);
+
+  if (bytes_read == 0)
+    return NULL;
+  return buf + bytes_read;
+}
+
+static inline const gdb_byte *
+gdb_skip_leb128 (const gdb_byte *buf, const gdb_byte *buf_end)
+{
+  size_t bytes_read = skip_leb128 (buf, buf_end);
+
+  if (bytes_read == 0)
+    return NULL;
+  return buf + bytes_read;
+}
+
+extern const gdb_byte *safe_read_uleb128 (const gdb_byte *buf,
+					  const gdb_byte *buf_end,
+					  unsigned long long *r);
+
+extern const gdb_byte *safe_read_sleb128 (const gdb_byte *buf,
+					  const gdb_byte *buf_end,
+					  long long *r);
+
+extern const gdb_byte *safe_skip_leb128 (const gdb_byte *buf,
+					 const gdb_byte *buf_end);
+
 #endif /* dwarf2expr.h */
diff --git a/gdb/dwarf2loc.c b/gdb/dwarf2loc.c
index c251b70c9cc..9bd77417e4d 100644
--- a/gdb/dwarf2loc.c
+++ b/gdb/dwarf2loc.c
@@ -58,6 +58,121 @@ static struct value *dwarf2_evaluate_loc_desc_full (struct type *type,
 					      struct dwarf2_per_cu_data *per_cu,
 						    LONGEST byte_offset);
 
+/* Until these have formal names, we define these here.
+   ref: http://gcc.gnu.org/wiki/DebugFission
+   Each entry in .debug_loc.dwo begins with a byte that describes the entry,
+   and is then followed by data specific to that entry.  */
+
+enum debug_loc_kind
+{
+  /* Indicates the end of the list of entries.  */
+  DEBUG_LOC_END_OF_LIST = 0,
+
+  /* This is followed by an unsigned LEB128 number that is an index into
+     .debug_addr and specifies the base address for all following entries.  */
+  DEBUG_LOC_BASE_ADDRESS = 1,
+
+  /* This is followed by two unsigned LEB128 numbers that are indices into
+     .debug_addr and specify the beginning and ending addresses, and then
+     a normal location expression as in .debug_loc.  */
+  DEBUG_LOC_NORMAL = 2,
+
+  /* An internal value indicating there is insufficient data.  */
+  DEBUG_LOC_BUFFER_OVERFLOW = -1,
+
+  /* An internal value indicating an invalid kind of entry was found.  */
+  DEBUG_LOC_INVALID_ENTRY = -2
+};
+
+/* Decode the addresses in a non-dwo .debug_loc entry.
+   A pointer to the next byte to examine is returned in *NEW_PTR.
+   The encoded low,high addresses are return in *LOW,*HIGH.
+   The result indicates the kind of entry found.  */
+
+static enum debug_loc_kind
+decode_debug_loc_addresses (const gdb_byte *loc_ptr, const gdb_byte *buf_end,
+			    const gdb_byte **new_ptr,
+			    CORE_ADDR *low, CORE_ADDR *high,
+			    enum bfd_endian byte_order,
+			    unsigned int addr_size,
+			    int signed_addr_p)
+{
+  CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
+
+  if (buf_end - loc_ptr < 2 * addr_size)
+    return DEBUG_LOC_BUFFER_OVERFLOW;
+
+  if (signed_addr_p)
+    *low = extract_signed_integer (loc_ptr, addr_size, byte_order);
+  else
+    *low = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
+  loc_ptr += addr_size;
+
+  if (signed_addr_p)
+    *high = extract_signed_integer (loc_ptr, addr_size, byte_order);
+  else
+    *high = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
+  loc_ptr += addr_size;
+
+  *new_ptr = loc_ptr;
+
+  /* A base-address-selection entry.  */
+  if ((*low & base_mask) == base_mask)
+    return DEBUG_LOC_BASE_ADDRESS;
+
+  /* An end-of-list entry.  */
+  if (*low == 0 && *high == 0)
+    return DEBUG_LOC_END_OF_LIST;
+
+  return DEBUG_LOC_NORMAL;
+}
+
+/* Decode the addresses in .debug_loc.dwo entry.
+   A pointer to the next byte to examine is returned in *NEW_PTR.
+   The encoded low,high addresses are return in *LOW,*HIGH.
+   The result indicates the kind of entry found.  */
+
+static enum debug_loc_kind
+decode_debug_loc_dwo_addresses (struct dwarf2_per_cu_data *per_cu,
+				const gdb_byte *loc_ptr,
+				const gdb_byte *buf_end,
+				const gdb_byte **new_ptr,
+				CORE_ADDR *low, CORE_ADDR *high)
+{
+  unsigned long long low_index, high_index;
+
+  if (loc_ptr == buf_end)
+    return DEBUG_LOC_BUFFER_OVERFLOW;
+
+  switch (*loc_ptr++)
+    {
+    case DEBUG_LOC_END_OF_LIST:
+      *new_ptr = loc_ptr;
+      return DEBUG_LOC_END_OF_LIST;
+    case DEBUG_LOC_BASE_ADDRESS:
+      *low = 0;
+      loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &high_index);
+      if (loc_ptr == NULL)
+	return DEBUG_LOC_BUFFER_OVERFLOW;
+      *high = dwarf2_read_addr_index (per_cu, high_index);
+      *new_ptr = loc_ptr;
+      return DEBUG_LOC_BASE_ADDRESS;
+    case DEBUG_LOC_NORMAL:
+      loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &low_index);
+      if (loc_ptr == NULL)
+	return DEBUG_LOC_BUFFER_OVERFLOW;
+      *low = dwarf2_read_addr_index (per_cu, low_index);
+      loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &high_index);
+      if (loc_ptr == NULL)
+	return DEBUG_LOC_BUFFER_OVERFLOW;
+      *high = dwarf2_read_addr_index (per_cu, high_index);
+      *new_ptr = loc_ptr;
+      return DEBUG_LOC_NORMAL;
+    default:
+      return DEBUG_LOC_INVALID_ENTRY;
+    }
+}
+
 /* A function for dealing with location lists.  Given a
    symbol baton (BATON) and a pc value (PC), find the appropriate
    location expression, set *LOCEXPR_LENGTH, and return a pointer
@@ -70,52 +185,52 @@ const gdb_byte *
 dwarf2_find_location_expression (struct dwarf2_loclist_baton *baton,
 				 size_t *locexpr_length, CORE_ADDR pc)
 {
-  CORE_ADDR low, high;
-  const gdb_byte *loc_ptr, *buf_end;
-  int length;
   struct objfile *objfile = dwarf2_per_cu_objfile (baton->per_cu);
   struct gdbarch *gdbarch = get_objfile_arch (objfile);
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   unsigned int addr_size = dwarf2_per_cu_addr_size (baton->per_cu);
   int signed_addr_p = bfd_get_sign_extend_vma (objfile->obfd);
-  CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
   /* Adjust base_address for relocatable objects.  */
   CORE_ADDR base_offset = dwarf2_per_cu_text_offset (baton->per_cu);
   CORE_ADDR base_address = baton->base_address + base_offset;
+  const gdb_byte *loc_ptr, *buf_end;
 
   loc_ptr = baton->data;
   buf_end = baton->data + baton->size;
 
   while (1)
     {
-      if (buf_end - loc_ptr < 2 * addr_size)
-	error (_("dwarf2_find_location_expression: "
-		 "Corrupted DWARF expression."));
-
-      if (signed_addr_p)
-	low = extract_signed_integer (loc_ptr, addr_size, byte_order);
-      else
-	low = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
-      loc_ptr += addr_size;
-
-      if (signed_addr_p)
-	high = extract_signed_integer (loc_ptr, addr_size, byte_order);
+      CORE_ADDR low = 0, high = 0; /* init for gcc -Wall */
+      int length;
+      enum debug_loc_kind kind;
+      const gdb_byte *new_ptr = NULL; /* init for gcc -Wall */
+
+      if (baton->from_dwo)
+	kind = decode_debug_loc_dwo_addresses (baton->per_cu,
+					       loc_ptr, buf_end, &new_ptr,
+					       &low, &high);
       else
-	high = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
-      loc_ptr += addr_size;
-
-      /* A base-address-selection entry.  */
-      if ((low & base_mask) == base_mask)
-	{
-	  base_address = high + base_offset;
-	  continue;
-	}
-
-      /* An end-of-list entry.  */
-      if (low == 0 && high == 0)
+	kind = decode_debug_loc_addresses (loc_ptr, buf_end, &new_ptr,
+					   &low, &high,
+					   byte_order, addr_size,
+					   signed_addr_p);
+      loc_ptr = new_ptr;
+      switch (kind)
 	{
+	case DEBUG_LOC_END_OF_LIST:
 	  *locexpr_length = 0;
 	  return NULL;
+	case DEBUG_LOC_BASE_ADDRESS:
+	  base_address = high + base_offset;
+	  continue;
+	case DEBUG_LOC_NORMAL:
+	  break;
+	case DEBUG_LOC_BUFFER_OVERFLOW:
+	case DEBUG_LOC_INVALID_ENTRY:
+	  error (_("dwarf2_find_location_expression: "
+		   "Corrupted DWARF expression."));
+	default:
+	  gdb_assert_not_reached ("bad debug_loc_kind");
 	}
 
       /* Otherwise, a location expression entry.  */
@@ -2451,8 +2566,8 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc,
   while (op_ptr < op_end)
     {
       enum dwarf_location_atom op = *op_ptr;
-      ULONGEST uoffset, reg;
-      LONGEST offset;
+      unsigned long long uoffset, reg;
+      long long offset;
       int i;
 
       offsets[op_ptr - base] = expr->len;
@@ -2556,11 +2671,11 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc,
 	  op_ptr += 8;
 	  break;
 	case DW_OP_constu:
-	  op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
+	  op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
 	  ax_const_l (expr, uoffset);
 	  break;
 	case DW_OP_consts:
-	  op_ptr = read_sleb128 (op_ptr, op_end, &offset);
+	  op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
 	  ax_const_l (expr, offset);
 	  break;
 
@@ -2602,7 +2717,7 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc,
 	  break;
 
 	case DW_OP_regx:
-	  op_ptr = read_uleb128 (op_ptr, op_end, &reg);
+	  op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
 	  dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
 	  loc->u.reg = translate_register (arch, reg);
 	  loc->kind = axs_lvalue_register;
@@ -2610,9 +2725,9 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc,
 
 	case DW_OP_implicit_value:
 	  {
-	    ULONGEST len;
+	    unsigned long long len;
 
-	    op_ptr = read_uleb128 (op_ptr, op_end, &len);
+	    op_ptr = safe_read_uleb128 (op_ptr, op_end, &len);
 	    if (op_ptr + len > op_end)
 	      error (_("DW_OP_implicit_value: too few bytes available."));
 	    if (len > sizeof (ULONGEST))
@@ -2666,7 +2781,7 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc,
 	case DW_OP_breg29:
 	case DW_OP_breg30:
 	case DW_OP_breg31:
-	  op_ptr = read_sleb128 (op_ptr, op_end, &offset);
+	  op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
 	  i = translate_register (arch, op - DW_OP_breg0);
 	  ax_reg (expr, i);
 	  if (offset != 0)
@@ -2677,8 +2792,8 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc,
 	  break;
 	case DW_OP_bregx:
 	  {
-	    op_ptr = read_uleb128 (op_ptr, op_end, &reg);
-	    op_ptr = read_sleb128 (op_ptr, op_end, &offset);
+	    op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
+	    op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
 	    i = translate_register (arch, reg);
 	    ax_reg (expr, i);
 	    if (offset != 0)
@@ -2709,7 +2824,7 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc,
 	    dwarf_expr_frame_base_1 (framefunc, expr->scope,
 				     &datastart, &datalen);
 
-	    op_ptr = read_sleb128 (op_ptr, op_end, &offset);
+	    op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
 	    dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size, datastart,
 				       datastart + datalen, per_cu);
 
@@ -2810,7 +2925,7 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc,
 	  break;
 
 	case DW_OP_plus_uconst:
-	  op_ptr = read_uleb128 (op_ptr, op_end, &reg);
+	  op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
 	  /* It would be really weird to emit `DW_OP_plus_uconst 0',
 	     but we micro-optimize anyhow.  */
 	  if (reg != 0)
@@ -2960,20 +3075,20 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc,
         case DW_OP_piece:
 	case DW_OP_bit_piece:
 	  {
-	    ULONGEST size, offset;
+	    unsigned long long size, offset;
 
 	    if (op_ptr - 1 == previous_piece)
 	      error (_("Cannot translate empty pieces to agent expressions"));
 	    previous_piece = op_ptr - 1;
 
-            op_ptr = read_uleb128 (op_ptr, op_end, &size);
+            op_ptr = safe_read_uleb128 (op_ptr, op_end, &size);
 	    if (op == DW_OP_piece)
 	      {
 		size *= 8;
 		offset = 0;
 	      }
 	    else
-	      op_ptr = read_uleb128 (op_ptr, op_end, &offset);
+	      op_ptr = safe_read_uleb128 (op_ptr, op_end, &offset);
 
 	    if (bits_collected + size > 8 * sizeof (LONGEST))
 	      error (_("Expression pieces exceed word size"));
@@ -3133,7 +3248,8 @@ locexpr_regname (struct gdbarch *gdbarch, int dwarf_regnum)
 /* Nicely describe a single piece of a location, returning an updated
    position in the bytecode sequence.  This function cannot recognize
    all locations; if a location is not recognized, it simply returns
-   DATA.  */
+   DATA.  If there is an error during reading, e.g. we run off the end
+   of the buffer, an error is thrown.  */
 
 static const gdb_byte *
 locexpr_describe_location_piece (struct symbol *symbol, struct ui_file *stream,
@@ -3151,9 +3267,9 @@ locexpr_describe_location_piece (struct symbol *symbol, struct ui_file *stream,
     }
   else if (data[0] == DW_OP_regx)
     {
-      ULONGEST reg;
+      unsigned long long reg;
 
-      data = read_uleb128 (data + 1, end, &reg);
+      data = safe_read_uleb128 (data + 1, end, &reg);
       fprintf_filtered (stream, _("a variable in $%s"),
 			locexpr_regname (gdbarch, reg));
     }
@@ -3162,12 +3278,12 @@ locexpr_describe_location_piece (struct symbol *symbol, struct ui_file *stream,
       struct block *b;
       struct symbol *framefunc;
       int frame_reg = 0;
-      LONGEST frame_offset;
+      long long frame_offset;
       const gdb_byte *base_data, *new_data, *save_data = data;
       size_t base_size;
-      LONGEST base_offset = 0;
+      long long base_offset = 0;
 
-      new_data = read_sleb128 (data + 1, end, &frame_offset);
+      new_data = safe_read_sleb128 (data + 1, end, &frame_offset);
       if (!piece_end_p (new_data, end))
 	return data;
       data = new_data;
@@ -3191,8 +3307,8 @@ locexpr_describe_location_piece (struct symbol *symbol, struct ui_file *stream,
 	  const gdb_byte *buf_end;
 	  
 	  frame_reg = base_data[0] - DW_OP_breg0;
-	  buf_end = read_sleb128 (base_data + 1,
-				  base_data + base_size, &base_offset);
+	  buf_end = safe_read_sleb128 (base_data + 1, base_data + base_size,
+				       &base_offset);
 	  if (buf_end != base_data + base_size)
 	    error (_("Unexpected opcode after "
 		     "DW_OP_breg%u for symbol \"%s\"."),
@@ -3219,9 +3335,9 @@ locexpr_describe_location_piece (struct symbol *symbol, struct ui_file *stream,
   else if (data[0] >= DW_OP_breg0 && data[0] <= DW_OP_breg31
 	   && piece_end_p (data, end))
     {
-      LONGEST offset;
+      long long offset;
 
-      data = read_sleb128 (data + 1, end, &offset);
+      data = safe_read_sleb128 (data + 1, end, &offset);
 
       fprintf_filtered (stream,
 			_("a variable at offset %s from base reg $%s"),
@@ -3276,7 +3392,9 @@ locexpr_describe_location_piece (struct symbol *symbol, struct ui_file *stream,
 /* Disassemble an expression, stopping at the end of a piece or at the
    end of the expression.  Returns a pointer to the next unread byte
    in the input expression.  If ALL is nonzero, then this function
-   will keep going until it reaches the end of the expression.  */
+   will keep going until it reaches the end of the expression.
+   If there is an error during reading, e.g. we run off the end
+   of the buffer, an error is thrown.  */
 
 static const gdb_byte *
 disassemble_dwarf_expression (struct ui_file *stream,
@@ -3291,8 +3409,8 @@ disassemble_dwarf_expression (struct ui_file *stream,
 	     || (data[0] != DW_OP_piece && data[0] != DW_OP_bit_piece)))
     {
       enum dwarf_location_atom op = *data++;
-      ULONGEST ul;
-      LONGEST l;
+      unsigned long long ul;
+      long long l;
       const char *name;
 
       name = get_DW_OP_name (op);
@@ -3353,11 +3471,11 @@ disassemble_dwarf_expression (struct ui_file *stream,
 	  fprintf_filtered (stream, " %s", plongest (l));
 	  break;
 	case DW_OP_constu:
-	  data = read_uleb128 (data, end, &ul);
+	  data = safe_read_uleb128 (data, end, &ul);
 	  fprintf_filtered (stream, " %s", pulongest (ul));
 	  break;
 	case DW_OP_consts:
-	  data = read_sleb128 (data, end, &l);
+	  data = safe_read_sleb128 (data, end, &l);
 	  fprintf_filtered (stream, " %s", plongest (l));
 	  break;
 
@@ -3398,13 +3516,13 @@ disassemble_dwarf_expression (struct ui_file *stream,
 	  break;
 
 	case DW_OP_regx:
-	  data = read_uleb128 (data, end, &ul);
+	  data = safe_read_uleb128 (data, end, &ul);
 	  fprintf_filtered (stream, " %s [$%s]", pulongest (ul),
 			    locexpr_regname (arch, (int) ul));
 	  break;
 
 	case DW_OP_implicit_value:
-	  data = read_uleb128 (data, end, &ul);
+	  data = safe_read_uleb128 (data, end, &ul);
 	  data += ul;
 	  fprintf_filtered (stream, " %s", pulongest (ul));
 	  break;
@@ -3441,14 +3559,14 @@ disassemble_dwarf_expression (struct ui_file *stream,
 	case DW_OP_breg29:
 	case DW_OP_breg30:
 	case DW_OP_breg31:
-	  data = read_sleb128 (data, end, &l);
+	  data = safe_read_sleb128 (data, end, &l);
 	  fprintf_filtered (stream, " %s [$%s]", plongest (l),
 			    locexpr_regname (arch, op - DW_OP_breg0));
 	  break;
 
 	case DW_OP_bregx:
-	  data = read_uleb128 (data, end, &ul);
-	  data = read_sleb128 (data, end, &l);
+	  data = safe_read_uleb128 (data, end, &ul);
+	  data = safe_read_sleb128 (data, end, &l);
 	  fprintf_filtered (stream, " register %s [$%s] offset %s",
 			    pulongest (ul),
 			    locexpr_regname (arch, (int) ul),
@@ -3456,7 +3574,7 @@ disassemble_dwarf_expression (struct ui_file *stream,
 	  break;
 
 	case DW_OP_fbreg:
-	  data = read_sleb128 (data, end, &l);
+	  data = safe_read_sleb128 (data, end, &l);
 	  fprintf_filtered (stream, " %s", plongest (l));
 	  break;
 
@@ -3468,7 +3586,7 @@ disassemble_dwarf_expression (struct ui_file *stream,
 	  break;
 
 	case DW_OP_plus_uconst:
-	  data = read_uleb128 (data, end, &ul);
+	  data = safe_read_uleb128 (data, end, &ul);
 	  fprintf_filtered (stream, " %s", pulongest (ul));
 	  break;
 
@@ -3506,16 +3624,16 @@ disassemble_dwarf_expression (struct ui_file *stream,
 	  break;
 
         case DW_OP_piece:
-	  data = read_uleb128 (data, end, &ul);
+	  data = safe_read_uleb128 (data, end, &ul);
 	  fprintf_filtered (stream, " %s (bytes)", pulongest (ul));
 	  break;
 
 	case DW_OP_bit_piece:
 	  {
-	    ULONGEST offset;
+	    unsigned long long offset;
 
-	    data = read_uleb128 (data, end, &ul);
-	    data = read_uleb128 (data, end, &offset);
+	    data = safe_read_uleb128 (data, end, &ul);
+	    data = safe_read_uleb128 (data, end, &offset);
 	    fprintf_filtered (stream, " size %s offset %s (bits)",
 			      pulongest (ul), pulongest (offset));
 	  }
@@ -3527,7 +3645,7 @@ disassemble_dwarf_expression (struct ui_file *stream,
 					   gdbarch_byte_order (arch));
 	    data += offset_size;
 
-	    data = read_sleb128 (data, end, &l);
+	    data = safe_read_sleb128 (data, end, &l);
 
 	    fprintf_filtered (stream, " DIE %s offset %s",
 			      phex_nz (ul, offset_size),
@@ -3541,7 +3659,7 @@ disassemble_dwarf_expression (struct ui_file *stream,
 	    cu_offset offset;
 	    struct type *type;
 
-	    data = read_uleb128 (data, end, &ul);
+	    data = safe_read_uleb128 (data, end, &ul);
 	    offset.cu_off = ul;
 	    type = dwarf2_get_die_type (offset, per_cu);
 	    fprintf_filtered (stream, "<");
@@ -3556,7 +3674,7 @@ disassemble_dwarf_expression (struct ui_file *stream,
 	    cu_offset type_die;
 	    struct type *type;
 
-	    data = read_uleb128 (data, end, &ul);
+	    data = safe_read_uleb128 (data, end, &ul);
 	    type_die.cu_off = ul;
 	    type = dwarf2_get_die_type (type_die, per_cu);
 	    fprintf_filtered (stream, "<");
@@ -3567,12 +3685,12 @@ disassemble_dwarf_expression (struct ui_file *stream,
 
 	case DW_OP_GNU_regval_type:
 	  {
-	    ULONGEST reg;
+	    unsigned long long reg;
 	    cu_offset type_die;
 	    struct type *type;
 
-	    data = read_uleb128 (data, end, &reg);
-	    data = read_uleb128 (data, end, &ul);
+	    data = safe_read_uleb128 (data, end, &reg);
+	    data = safe_read_uleb128 (data, end, &ul);
 	    type_die.cu_off = ul;
 
 	    type = dwarf2_get_die_type (type_die, per_cu);
@@ -3589,7 +3707,7 @@ disassemble_dwarf_expression (struct ui_file *stream,
 	  {
 	    cu_offset type_die;
 
-	    data = read_uleb128 (data, end, &ul);
+	    data = safe_read_uleb128 (data, end, &ul);
 	    type_die.cu_off = ul;
 
 	    if (type_die.cu_off == 0)
@@ -3607,7 +3725,7 @@ disassemble_dwarf_expression (struct ui_file *stream,
 	  break;
 
 	case DW_OP_GNU_entry_value:
-	  data = read_uleb128 (data, end, &ul);
+	  data = safe_read_uleb128 (data, end, &ul);
 	  fputc_filtered ('\n', stream);
 	  disassemble_dwarf_expression (stream, arch, addr_size, offset_size,
 					start, data, data + ul, indent + 2,
@@ -3676,9 +3794,9 @@ locexpr_describe_location_1 (struct symbol *symbol, CORE_ADDR addr,
 	    fprintf_filtered (stream, "   ");
 	  if (data[0] == DW_OP_piece)
 	    {
-	      ULONGEST bytes;
+	      unsigned long long bytes;
 
-	      data = read_uleb128 (data + 1, end, &bytes);
+	      data = safe_read_uleb128 (data + 1, end, &bytes);
 
 	      if (empty)
 		fprintf_filtered (stream, _("an empty %s-byte piece"),
@@ -3689,10 +3807,10 @@ locexpr_describe_location_1 (struct symbol *symbol, CORE_ADDR addr,
 	    }
 	  else if (data[0] == DW_OP_bit_piece)
 	    {
-	      ULONGEST bits, offset;
+	      unsigned long long bits, offset;
 
-	      data = read_uleb128 (data + 1, end, &bits);
-	      data = read_uleb128 (data, end, &offset);
+	      data = safe_read_uleb128 (data + 1, end, &bits);
+	      data = safe_read_uleb128 (data, end, &offset);
 
 	      if (empty)
 		fprintf_filtered (stream,
@@ -3832,19 +3950,18 @@ loclist_describe_location (struct symbol *symbol, CORE_ADDR addr,
 			   struct ui_file *stream)
 {
   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
-  CORE_ADDR low, high;
   const gdb_byte *loc_ptr, *buf_end;
-  int length, first = 1;
+  int first = 1;
   struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
   struct gdbarch *gdbarch = get_objfile_arch (objfile);
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
   int offset_size = dwarf2_per_cu_offset_size (dlbaton->per_cu);
   int signed_addr_p = bfd_get_sign_extend_vma (objfile->obfd);
-  CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
   /* Adjust base_address for relocatable objects.  */
   CORE_ADDR base_offset = dwarf2_per_cu_text_offset (dlbaton->per_cu);
   CORE_ADDR base_address = dlbaton->base_address + base_offset;
+  int done = 0;
 
   loc_ptr = dlbaton->data;
   buf_end = dlbaton->data + dlbaton->size;
@@ -3852,37 +3969,43 @@ loclist_describe_location (struct symbol *symbol, CORE_ADDR addr,
   fprintf_filtered (stream, _("multi-location:\n"));
 
   /* Iterate through locations until we run out.  */
-  while (1)
+  while (!done)
     {
-      if (buf_end - loc_ptr < 2 * addr_size)
-	error (_("Corrupted DWARF expression for symbol \"%s\"."),
-	       SYMBOL_PRINT_NAME (symbol));
-
-      if (signed_addr_p)
-	low = extract_signed_integer (loc_ptr, addr_size, byte_order);
-      else
-	low = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
-      loc_ptr += addr_size;
-
-      if (signed_addr_p)
-	high = extract_signed_integer (loc_ptr, addr_size, byte_order);
+      CORE_ADDR low = 0, high = 0; /* init for gcc -Wall */
+      int length;
+      enum debug_loc_kind kind;
+      const gdb_byte *new_ptr = NULL; /* init for gcc -Wall */
+
+      if (dlbaton->from_dwo)
+	kind = decode_debug_loc_dwo_addresses (dlbaton->per_cu,
+					       loc_ptr, buf_end, &new_ptr,
+					       &low, &high);
       else
-	high = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
-      loc_ptr += addr_size;
-
-      /* A base-address-selection entry.  */
-      if ((low & base_mask) == base_mask)
+	kind = decode_debug_loc_addresses (loc_ptr, buf_end, &new_ptr,
+					   &low, &high,
+					   byte_order, addr_size,
+					   signed_addr_p);
+      loc_ptr = new_ptr;
+      switch (kind)
 	{
+	case DEBUG_LOC_END_OF_LIST:
+	  done = 1;
+	  continue;
+	case DEBUG_LOC_BASE_ADDRESS:
 	  base_address = high + base_offset;
 	  fprintf_filtered (stream, _("  Base address %s"),
 			    paddress (gdbarch, base_address));
 	  continue;
+	case DEBUG_LOC_NORMAL:
+	  break;
+	case DEBUG_LOC_BUFFER_OVERFLOW:
+	case DEBUG_LOC_INVALID_ENTRY:
+	  error (_("Corrupted DWARF expression for symbol \"%s\"."),
+		 SYMBOL_PRINT_NAME (symbol));
+	default:
+	  gdb_assert_not_reached ("bad debug_loc_kind");
 	}
 
-      /* An end-of-list entry.  */
-      if (low == 0 && high == 0)
-	break;
-
       /* Otherwise, a location expression entry.  */
       low += base_address;
       high += base_address;
diff --git a/gdb/dwarf2loc.h b/gdb/dwarf2loc.h
index 370402e0a42..e9d06a330d3 100644
--- a/gdb/dwarf2loc.h
+++ b/gdb/dwarf2loc.h
@@ -119,6 +119,10 @@ struct dwarf2_loclist_baton
   /* The compilation unit containing the symbol whose location
      we're computing.  */
   struct dwarf2_per_cu_data *per_cu;
+
+  /* Non-zero if the location list lives in .debug_loc.dwo.
+     The format of entries in this section are different.  */
+  unsigned char from_dwo;
 };
 
 extern const struct symbol_computed_ops dwarf2_locexpr_funcs;
diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c
index 6ddf23657b6..b590134d476 100644
--- a/gdb/dwarf2read.c
+++ b/gdb/dwarf2read.c
@@ -606,6 +606,9 @@ struct die_reader_specs
 
   /* die_section->buffer.  */
   gdb_byte *buffer;
+
+  /* The end of the buffer.  */
+  const gdb_byte *buffer_end;
 };
 
 /* Type of function passed to init_cutu_and_read_dies, et.al.  */
@@ -968,11 +971,13 @@ dwarf2_const_value_length_mismatch_complaint (const char *arg1, int arg2,
 }
 
 static void
-dwarf2_macros_too_long_complaint (struct dwarf2_section_info *section)
+dwarf2_section_buffer_overflow_complaint (struct dwarf2_section_info *section)
 {
   complaint (&symfile_complaints,
-	     _("macro info runs off end of `%s' section"),
-	     section->asection->name);
+	     _("debug info runs off end of %s section"
+	       " [in module %s]"),
+	     section->asection->name,
+	     bfd_get_filename (section->asection->owner));
 }
 
 static void
@@ -1104,8 +1109,6 @@ static CORE_ADDR read_addr_index_from_leb128 (struct dwarf2_cu *, gdb_byte *,
 static char *read_str_index (const struct die_reader_specs *reader,
 			     struct dwarf2_cu *cu, ULONGEST str_index);
 
-static gdb_byte *skip_leb128 (bfd *, gdb_byte *);
-
 static void set_cu_language (unsigned int, struct dwarf2_cu *);
 
 static struct attribute *dwarf2_attr (struct die_info *, unsigned int,
@@ -3656,6 +3659,7 @@ init_cu_die_reader (struct die_reader_specs *reader,
   reader->dwo_file = dwo_file;
   reader->die_section = section;
   reader->buffer = section->buffer;
+  reader->buffer_end = section->buffer + section->size;
 }
 
 /* Find the base address of the compilation unit for range lists and
@@ -5034,6 +5038,8 @@ skip_one_die (const struct die_reader_specs *reader, gdb_byte *info_ptr,
   bfd *abfd = reader->abfd;
   struct dwarf2_cu *cu = reader->cu;
   gdb_byte *buffer = reader->buffer;
+  const gdb_byte *buffer_end = reader->buffer_end;
+  gdb_byte *start_info_ptr = info_ptr;
   unsigned int form, i;
 
   for (i = 0; i < abbrev->num_attrs; i++)
@@ -5112,7 +5118,7 @@ skip_one_die (const struct die_reader_specs *reader, gdb_byte *info_ptr,
 	case DW_FORM_ref_udata:
 	case DW_FORM_GNU_addr_index:
 	case DW_FORM_GNU_str_index:
-	  info_ptr = skip_leb128 (abfd, info_ptr);
+	  info_ptr = (gdb_byte *) safe_skip_leb128 (info_ptr, buffer_end);
 	  break;
 	case DW_FORM_indirect:
 	  form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
@@ -12273,22 +12279,6 @@ read_str_index (const struct die_reader_specs *reader,
   return (char *) (sections->str.buffer + str_offset);
 }
 
-/* Return a pointer to just past the end of an LEB128 number in BUF.  */
-
-static gdb_byte *
-skip_leb128 (bfd *abfd, gdb_byte *buf)
-{
-  int byte;
-
-  while (1)
-    {
-      byte = bfd_get_8 (abfd, buf);
-      buf++;
-      if ((byte & 128) == 0)
-	return buf;
-    }
-}
-
 /* Return the length of an LEB128 number in BUF.  */
 
 static int
@@ -15783,7 +15773,7 @@ parse_macro_definition (struct macro_source_file *file, int line,
    Returns the new pointer.  */
 
 static gdb_byte *
-skip_form_bytes (bfd *abfd, gdb_byte *bytes,
+skip_form_bytes (bfd *abfd, gdb_byte *bytes, gdb_byte *buffer_end,
 		 enum dwarf_form form,
 		 unsigned int offset_size,
 		 struct dwarf2_section_info *section)
@@ -15838,7 +15828,12 @@ skip_form_bytes (bfd *abfd, gdb_byte *bytes,
     case DW_FORM_udata:
     case DW_FORM_GNU_addr_index:
     case DW_FORM_GNU_str_index:
-      bytes = skip_leb128 (abfd, bytes);
+      bytes = (gdb_byte *) gdb_skip_leb128 (bytes, buffer_end);
+      if (bytes == NULL)
+	{
+	  dwarf2_section_buffer_overflow_complaint (section);
+	  return NULL;
+	}
       break;
 
     default:
@@ -15862,7 +15857,7 @@ skip_form_bytes (bfd *abfd, gdb_byte *bytes,
 static gdb_byte *
 skip_unknown_opcode (unsigned int opcode,
 		     gdb_byte **opcode_definitions,
-		     gdb_byte *mac_ptr,
+		     gdb_byte *mac_ptr, gdb_byte *mac_end,
 		     bfd *abfd,
 		     unsigned int offset_size,
 		     struct dwarf2_section_info *section)
@@ -15885,7 +15880,8 @@ skip_unknown_opcode (unsigned int opcode,
 
   for (i = 0; i < arg; ++i)
     {
-      mac_ptr = skip_form_bytes (abfd, mac_ptr, defn[i], offset_size, section);
+      mac_ptr = skip_form_bytes (abfd, mac_ptr, mac_end, defn[i], offset_size,
+				 section);
       if (mac_ptr == NULL)
 	{
 	  /* skip_form_bytes already issued the complaint.  */
@@ -15996,7 +15992,7 @@ dwarf_decode_macro_bytes (bfd *abfd, gdb_byte *mac_ptr, gdb_byte *mac_end,
       /* Do we at least have room for a macinfo type byte?  */
       if (mac_ptr >= mac_end)
 	{
-	  dwarf2_macros_too_long_complaint (section);
+	  dwarf2_section_buffer_overflow_complaint (section);
 	  break;
 	}
 
@@ -16123,7 +16119,7 @@ dwarf_decode_macro_bytes (bfd *abfd, gdb_byte *mac_ptr, gdb_byte *mac_end,
                   /* Do we at least have room for a macinfo type byte?  */
                   if (mac_ptr >= mac_end)
                     {
-		      dwarf2_macros_too_long_complaint (section);
+		      dwarf2_section_buffer_overflow_complaint (section);
                       return;
                     }
 
@@ -16191,7 +16187,7 @@ dwarf_decode_macro_bytes (bfd *abfd, gdb_byte *mac_ptr, gdb_byte *mac_end,
 
 	default:
 	  mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
-					 mac_ptr, abfd, offset_size,
+					 mac_ptr, mac_end, abfd, offset_size,
 					 section);
 	  if (mac_ptr == NULL)
 	    return;
@@ -16334,7 +16330,7 @@ dwarf_decode_macros (struct line_header *lh, unsigned int offset,
 
 	default:
 	  mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
-					 mac_ptr, abfd, offset_size,
+					 mac_ptr, mac_end, abfd, offset_size,
 					 section);
 	  if (mac_ptr == NULL)
 	    return;
@@ -16450,6 +16446,7 @@ fill_in_loclist_baton (struct dwarf2_cu *cu,
   baton->size = section->size - DW_UNSND (attr);
   baton->data = section->buffer + DW_UNSND (attr);
   baton->base_address = cu->base_address;
+  baton->from_dwo = cu->dwo_unit != NULL;
 }
 
 static void