Lines Matching refs:readp
5135 unsigned char **readp, unsigned char *endp,
5147 || p->offset >= (Dwarf_Off) (endp - *readp + offset))
5149 *readp = endp;
5157 *readp += p->offset - offset;
5353 const unsigned char *readp = start;
5357 while (readp < readendp)
5366 Dwarf_Off off = (Dwarf_Off) (readp
5440 unit_length = (uint64_t) (next_unitp - readp);
5456 unit_length = read_4ubyte_unaligned_inc (dbg, readp);
5459 if (unlikely (readp > readendp - 8))
5465 unit_length = read_8ubyte_unaligned_inc (dbg, readp);
5475 if (readp > readendp - 4
5477 || unit_length > (uint64_t) (readendp - readp))
5480 next_unitp = readp + unit_length;
5482 version = read_2ubyte_unaligned_inc (dbg, readp);
5491 address_size = *readp++;
5501 segment_size = *readp++;
5512 if (listptr->offset != (Dwarf_Off) (readp - start))
5521 size_t addresses = (next_unitp - readp) / address_size;
5529 size_t index_offset = readp - (const unsigned char *) data->d_buf;
5531 while (readp <= next_unitp - address_size)
5534 readp);
5541 if (readp != next_unitp)
5543 (size_t) (next_unitp - readp));
5546 readp = next_unitp;
5645 const unsigned char *readp = data->d_buf;
5646 const unsigned char *readendp = readp + data->d_size;
5648 while (readp < readendp)
5650 const unsigned char *hdrstart = readp;
5654 if (readp + 4 > readendp)
5662 Dwarf_Word length = read_4ubyte_unaligned_inc (dbg, readp);
5666 if (readp + 8 > readendp)
5668 length = read_8ubyte_unaligned_inc (dbg, readp);
5672 const unsigned char *nexthdr = readp + length;
5676 if (unlikely (length > (size_t) (readendp - readp)))
5682 if (readp + 2 > readendp)
5684 uint_fast16_t version = read_2ubyte_unaligned_inc (dbg, readp);
5694 if (readp + length_bytes > readendp)
5697 offset = read_8ubyte_unaligned_inc (dbg, readp);
5699 offset = read_4ubyte_unaligned_inc (dbg, readp);
5703 if (readp + 1 > readendp)
5705 unsigned int address_size = *readp++;
5714 if (readp + 1 > readendp)
5716 unsigned int segment_size = *readp++;
5726 readp += ((2 * address_size - ((readp - hdrstart) % (2 * address_size)))
5729 while (readp < nexthdr)
5734 if (readp + 2 * address_size + segment_size > readendp)
5738 range_address = read_4ubyte_unaligned_inc (dbg, readp);
5739 range_length = read_4ubyte_unaligned_inc (dbg, readp);
5743 range_address = read_8ubyte_unaligned_inc (dbg, readp);
5744 range_length = read_8ubyte_unaligned_inc (dbg, readp);
5748 segment = read_4ubyte_unaligned_inc (dbg, readp);
5750 segment = read_8ubyte_unaligned_inc (dbg, readp);
5769 if (readp != nexthdr)
5771 size_t padding = nexthdr - readp;
5773 readp = nexthdr;
5825 const unsigned char *readp = data->d_buf;
5828 while (readp < dataend)
5830 if (unlikely (readp > dataend - 4))
5838 ptrdiff_t offset = readp - (unsigned char *) data->d_buf;
5842 uint64_t unit_length = read_4ubyte_unaligned_inc (dbg, readp);
5846 if (unlikely (readp > dataend - 8))
5849 unit_length = read_8ubyte_unaligned_inc (dbg, readp);
5857 if (readp > dataend - 8
5859 || unit_length > (uint64_t) (dataend - readp))
5862 const unsigned char *nexthdr = readp + unit_length;
5864 uint16_t version = read_2ubyte_unaligned_inc (dbg, readp);
5873 uint8_t address_size = *readp++;
5883 uint8_t segment_size = *readp++;
5893 uint32_t offset_entry_count = read_4ubyte_unaligned_inc (dbg, readp);
5922 const unsigned char *offset_array_start = readp;
5941 uint32_t off = read_4ubyte_unaligned_inc (dbg, readp);
5946 uint64_t off = read_8ubyte_unaligned_inc (dbg, readp);
5955 while (readp < nexthdr)
5957 uint8_t kind = *readp++;
5968 (uint64_t) (readp - (unsigned char *) data->d_buf - 1),
5969 (uint64_t) (readp - offset_array_start - 1));
5982 if ((uint64_t) (nexthdr - readp) < 1)
5988 get_uleb128 (op1, readp, nexthdr);
6005 if ((uint64_t) (nexthdr - readp) < 1)
6007 get_uleb128 (op1, readp, nexthdr);
6008 if ((uint64_t) (nexthdr - readp) < 1)
6010 get_uleb128 (op2, readp, nexthdr);
6035 if ((uint64_t) (nexthdr - readp) < 1)
6037 get_uleb128 (op1, readp, nexthdr);
6038 if ((uint64_t) (nexthdr - readp) < 1)
6040 get_uleb128 (op2, readp, nexthdr);
6065 if ((uint64_t) (nexthdr - readp) < 1)
6067 get_uleb128 (op1, readp, nexthdr);
6068 if ((uint64_t) (nexthdr - readp) < 1)
6070 get_uleb128 (op2, readp, nexthdr);
6087 if ((uint64_t) (nexthdr - readp) < 4)
6089 op1 = read_4ubyte_unaligned_inc (dbg, readp);
6093 if ((uint64_t) (nexthdr - readp) < 8)
6095 op1 = read_8ubyte_unaligned_inc (dbg, readp);
6110 if ((uint64_t) (nexthdr - readp) < 8)
6112 op1 = read_4ubyte_unaligned_inc (dbg, readp);
6113 op2 = read_4ubyte_unaligned_inc (dbg, readp);
6117 if ((uint64_t) (nexthdr - readp) < 16)
6119 op1 = read_8ubyte_unaligned_inc (dbg, readp);
6120 op2 = read_8ubyte_unaligned_inc (dbg, readp);
6136 if ((uint64_t) (nexthdr - readp) < 4)
6138 op1 = read_4ubyte_unaligned_inc (dbg, readp);
6142 if ((uint64_t) (nexthdr - readp) < 8)
6144 op1 = read_8ubyte_unaligned_inc (dbg, readp);
6146 if ((uint64_t) (nexthdr - readp) < 1)
6148 get_uleb128 (op2, readp, nexthdr);
6167 if (readp != nexthdr)
6169 size_t padding = nexthdr - readp;
6171 readp = nexthdr;
6205 unsigned char *readp = data->d_buf;
6207 while (readp < endp)
6209 ptrdiff_t offset = readp - (unsigned char *) data->d_buf;
6214 offset, &readp, endp, NULL))
6242 begin = read_8ubyte_unaligned_inc (dbg, readp);
6243 end = read_8ubyte_unaligned_inc (dbg, readp);
6247 begin = read_4ubyte_unaligned_inc (dbg, readp);
6248 end = read_4ubyte_unaligned_inc (dbg, readp);
6331 read_encoded (unsigned int encoding, const unsigned char *readp,
6341 get_uleb128 (*res, readp, endp);
6344 get_sleb128 (*res, readp, endp);
6347 if (readp + 2 > endp)
6349 *res = read_2ubyte_unaligned_inc (dbg, readp);
6352 if (readp + 4 > endp)
6354 *res = read_4ubyte_unaligned_inc (dbg, readp);
6357 if (readp + 8 > endp)
6359 *res = read_8ubyte_unaligned_inc (dbg, readp);
6362 if (readp + 2 > endp)
6364 *res = read_2sbyte_unaligned_inc (dbg, readp);
6367 if (readp + 4 > endp)
6369 *res = read_4sbyte_unaligned_inc (dbg, readp);
6372 if (readp + 8 > endp)
6374 *res = read_8sbyte_unaligned_inc (dbg, readp);
6382 return readp;
6394 print_cfa_program (const unsigned char *readp, const unsigned char *const endp,
6405 while (readp < endp)
6407 unsigned int opcode = *readp++;
6422 if ((uint64_t) (endp - readp) < 1)
6424 readp = read_encoded (encoding, readp, endp, &op1, dbg);
6429 if ((uint64_t) (endp - readp) < 1)
6432 *readp, pc += *readp * code_align);
6433 ++readp;
6436 if ((uint64_t) (endp - readp) < 2)
6438 op1 = read_2ubyte_unaligned_inc (dbg, readp);
6443 if ((uint64_t) (endp - readp) < 4)
6445 op1 = read_4ubyte_unaligned_inc (dbg, readp);
6450 if ((uint64_t) (endp - readp) < 1)
6452 get_uleb128 (op1, readp, endp);
6453 if ((uint64_t) (endp - readp) < 1)
6455 get_uleb128 (op2, readp, endp);
6461 if ((uint64_t) (endp - readp) < 1)
6463 get_uleb128 (op1, readp, endp);
6468 if ((uint64_t) (endp - readp) < 1)
6470 get_uleb128 (op1, readp, endp);
6475 if ((uint64_t) (endp - readp) < 1)
6477 get_uleb128 (op1, readp, endp);
6482 if ((uint64_t) (endp - readp) < 1)
6484 get_uleb128 (op1, readp, endp);
6485 if ((uint64_t) (endp - readp) < 1)
6487 get_uleb128 (op2, readp, endp);
6499 if ((uint64_t) (endp - readp) < 1)
6501 get_uleb128 (op1, readp, endp);
6502 if ((uint64_t) (endp - readp) < 1)
6504 get_uleb128 (op2, readp, endp);
6509 if ((uint64_t) (endp - readp) < 1)
6511 get_uleb128 (op1, readp, endp);
6516 if ((uint64_t) (endp - readp) < 1)
6518 get_uleb128 (op1, readp, endp);
6522 if ((uint64_t) (endp - readp) < 1)
6524 get_uleb128 (op1, readp, endp); /* Length of DW_FORM_block. */
6526 if ((uint64_t) (endp - readp) < op1)
6533 op1, readp);
6534 readp += op1;
6537 if ((uint64_t) (endp - readp) < 1)
6539 get_uleb128 (op1, readp, endp);
6540 if ((uint64_t) (endp - readp) < 1)
6542 get_uleb128 (op2, readp, endp); /* Length of DW_FORM_block. */
6545 if ((uint64_t) (endp - readp) < op2)
6548 op2, readp);
6549 readp += op2;
6552 if ((uint64_t) (endp - readp) < 1)
6554 get_uleb128 (op1, readp, endp);
6555 if ((uint64_t) (endp - readp) < 1)
6557 get_sleb128 (sop2, readp, endp);
6563 if ((uint64_t) (endp - readp) < 1)
6565 get_uleb128 (op1, readp, endp);
6566 if ((uint64_t) (endp - readp) < 1)
6568 get_sleb128 (sop2, readp, endp);
6573 if ((uint64_t) (endp - readp) < 1)
6575 get_sleb128 (sop1, readp, endp);
6579 if ((uint64_t) (endp - readp) < 1)
6581 get_uleb128 (op1, readp, endp);
6582 if ((uint64_t) (endp - readp) < 1)
6584 get_uleb128 (op2, readp, endp);
6589 if ((uint64_t) (endp - readp) < 1)
6591 get_uleb128 (op1, readp, endp);
6592 if ((uint64_t) (endp - readp) < 1)
6594 get_sleb128 (sop2, readp, endp);
6599 if ((uint64_t) (endp - readp) < 1)
6601 get_uleb128 (op1, readp, endp);
6602 if ((uint64_t) (endp - readp) < 1)
6604 get_uleb128 (op2, readp, endp); /* Length of DW_FORM_block. */
6607 if ((uint64_t) (endp - readp) < op2)
6610 NULL, op2, readp);
6611 readp += op2;
6614 if ((uint64_t) (endp - readp) < 8)
6616 op1 = read_8ubyte_unaligned_inc (dbg, readp);
6627 if ((uint64_t) (endp - readp) < 1)
6629 get_uleb128 (op1, readp, endp);
6642 if ((uint64_t) (endp - readp) < 1)
6644 get_uleb128 (offset, readp, endp);
6824 const unsigned char *readp = data->d_buf;
6827 while (readp < dataend)
6829 if (unlikely (readp + 4 > dataend))
6839 ptrdiff_t offset = readp - (unsigned char *) data->d_buf;
6841 Dwarf_Word unit_length = read_4ubyte_unaligned_inc (dbg, readp);
6845 if (unlikely (readp + 8 > dataend))
6848 unit_length = read_8ubyte_unaligned_inc (dbg, readp);
6858 Dwarf_Word maxsize = dataend - readp;
6864 ptrdiff_t start = readp - (unsigned char *) data->d_buf;
6865 const unsigned char *const cieend = readp + unit_length;
6872 if (unlikely (cieend - readp < 4))
6874 cie_id = read_4ubyte_unaligned_inc (dbg, readp);
6880 if (unlikely (cieend - readp < 8))
6882 cie_id = read_8ubyte_unaligned_inc (dbg, readp);
6895 if (unlikely (cieend - readp < 2))
6897 version = *readp++;
6898 const char *const augmentation = (const char *) readp;
6899 readp = memchr (readp, '\0', cieend - readp);
6900 if (unlikely (readp == NULL))
6902 ++readp;
6907 if (cieend - readp < 5)
6909 ptr_size = *readp++;
6910 segment_size = *readp++;
6913 if (cieend - readp < 1)
6915 get_uleb128 (code_alignment_factor, readp, cieend);
6916 if (cieend - readp < 1)
6918 get_sleb128 (data_alignment_factor, readp, cieend);
6922 readp += ehdr->e_ident[EI_CLASS] == ELFCLASS32 ? 4 : 8;
6925 if (cieend - readp < 1)
6928 return_address_register = *readp++;
6930 get_uleb128 (return_address_register, readp, cieend);
6951 get_uleb128 (augmentationlen, readp, cieend);
6953 if (augmentationlen > (size_t) (cieend - readp))
6956 readp = cieend;
6964 printf (" %-26s%#x ", hdr, *readp);
6969 fde_encoding = *readp++;
6975 lsda_encoding = *readp++;
6983 const unsigned char *startp = readp;
6984 unsigned int encoding = *readp++;
6986 readp = read_encoded (encoding, readp,
6987 readp - 1 + augmentationlen,
6990 while (++startp < readp)
7009 printf ("(%x)\n", *readp++);
7052 const unsigned char *base = readp;
7054 initial_location = read_addr_unaligned_inc (ptr_size, dbg, readp);
7056 = read_addr_unaligned_inc (ptr_size, dbg, readp);
7103 if (cieend - readp < 1)
7105 get_uleb128 (augmentationlen, readp, cieend);
7107 if (augmentationlen > (size_t) (cieend - readp))
7110 readp = cieend;
7126 = read_encoded (lsda_encoding, &readp[u],
7127 &readp[augmentationlen],
7129 u = p - readp;
7140 printf (" %-26s%#x\n", hdr, readp[u++]);
7145 readp += augmentationlen;
7153 print_cfa_program (readp, cieend, vma_base, code_alignment_factor,
7156 readp = cieend;
7791 const unsigned char *readp = block.data;
7792 const unsigned char *readendp = readp + block.length;
7819 while (readp < readendp)
7821 int d = (int) *readp++;
7823 if (readp >= readendp)
7832 get_sleb128 (sval, readp, readendp);
7837 get_uleb128 (val, readp, readendp);
7845 get_sleb128 (sval, readp, readendp);
7847 if (readp >= readendp)
7849 get_sleb128 (sval, readp, readendp);
7854 get_uleb128 (val, readp, readendp);
7856 if (readp >= readendp)
7858 get_uleb128 (val, readp, readendp);
7864 print_block (readendp - readp, readp);
7867 if (readp < readendp)
8312 Returns new value of readp, or readendp on failure. */
8314 print_form_data (Dwarf *dbg, int form, const unsigned char *readp,
8325 if (readendp - readp < 1)
8331 val = *readp++;
8336 if (readendp - readp < 2)
8338 val = read_2ubyte_unaligned_inc (dbg, readp);
8343 if (readendp - readp < 4)
8345 val = read_4ubyte_unaligned_inc (dbg, readp);
8350 if (readendp - readp < 8)
8352 val = read_8ubyte_unaligned_inc (dbg, readp);
8357 if (readendp - readp < 1)
8359 get_sleb128 (val, readp, readendp);
8364 if (readendp - readp < 1)
8366 get_uleb128 (val, readp, readendp);
8371 if (readendp - readp < 1)
8373 get_uleb128 (val, readp, readendp);
8374 if ((size_t) (readendp - readp) < val)
8376 print_bytes (val, readp);
8377 readp += val;
8381 if (readendp - readp < 1)
8383 val = *readp++;
8384 if ((size_t) (readendp - readp) < val)
8386 print_bytes (val, readp);
8387 readp += val;
8391 if (readendp - readp < 2)
8393 val = read_2ubyte_unaligned_inc (dbg, readp);
8394 if ((size_t) (readendp - readp) < val)
8396 print_bytes (val, readp);
8397 readp += val;
8401 if (readendp - readp < 4)
8403 val = read_4ubyte_unaligned_inc (dbg, readp);
8404 if ((size_t) (readendp - readp) < val)
8406 print_bytes (val, readp);
8407 readp += val;
8411 if (readendp - readp < 16)
8413 print_bytes (16, readp);
8414 readp += 16;
8418 if (readendp - readp < 1)
8420 val = *readp++;
8425 endp = memchr (readp, '\0', readendp - readp);
8428 printf ("%s", readp);
8429 readp = endp + 1;
8435 if ((size_t) (readendp - readp) < offset_len)
8438 val = read_8ubyte_unaligned_inc (dbg, readp);
8440 val = read_4ubyte_unaligned_inc (dbg, readp);
8459 if ((size_t) (readendp - readp) < offset_len)
8462 val = read_8ubyte_unaligned_inc (dbg, readp);
8464 val = read_4ubyte_unaligned_inc (dbg, readp);
8470 if (readendp - readp < 1)
8472 get_uleb128 (val, readp, readendp);
8505 if (readendp - readp < 1)
8507 val = *readp++;
8511 if (readendp - readp < 2)
8513 val = read_2ubyte_unaligned_inc (dbg, readp);
8517 if (readendp - readp < 3)
8519 val = read_3ubyte_unaligned_inc (dbg, readp);
8523 if (readendp - readp < 4)
8525 val = read_4ubyte_unaligned_inc (dbg, readp);
8533 return readp;
9327 const unsigned char *readp = data->d_buf;
9330 while (readp < dataend)
9332 if (unlikely (readp > dataend - 4))
9340 ptrdiff_t offset = readp - (unsigned char *) data->d_buf;
9344 uint64_t unit_length = read_4ubyte_unaligned_inc (dbg, readp);
9348 if (unlikely (readp > dataend - 8))
9351 unit_length = read_8ubyte_unaligned_inc (dbg, readp);
9359 if (readp > dataend - 8
9361 || unit_length > (uint64_t) (dataend - readp))
9364 const unsigned char *nexthdr = readp + unit_length;
9366 uint16_t version = read_2ubyte_unaligned_inc (dbg, readp);
9375 uint8_t address_size = *readp++;
9385 uint8_t segment_size = *readp++;
9395 uint32_t offset_entry_count = read_4ubyte_unaligned_inc (dbg, readp);
9424 const unsigned char *offset_array_start = readp;
9443 uint32_t off = read_4ubyte_unaligned_inc (dbg, readp);
9448 uint64_t off = read_8ubyte_unaligned_inc (dbg, readp);
9457 while (readp < nexthdr)
9459 Dwarf_Off off = (Dwarf_Off) (readp - (unsigned char *) data->d_buf);
9465 const unsigned char *locp = readp;
9475 (uint64_t) (readp - (unsigned char *) data->d_buf),
9476 (uint64_t) (readp - offset_array_start));
9492 readp = (unsigned char *) locendp;
9496 uint8_t kind = *readp++;
9507 (uint64_t) (readp - (unsigned char *) data->d_buf - 1),
9508 (uint64_t) (readp - offset_array_start - 1));
9521 if ((uint64_t) (nexthdr - readp) < 1)
9527 get_uleb128 (op1, readp, nexthdr);
9544 if ((uint64_t) (nexthdr - readp) < 1)
9546 get_uleb128 (op1, readp, nexthdr);
9547 if ((uint64_t) (nexthdr - readp) < 1)
9549 get_uleb128 (op2, readp, nexthdr);
9571 if ((uint64_t) (nexthdr - readp) < 1)
9573 get_uleb128 (len, readp, nexthdr);
9574 if ((uint64_t) (nexthdr - readp) < len)
9577 address_size, offset_size, cu, len, readp);
9578 readp += len;
9582 if ((uint64_t) (nexthdr - readp) < 1)
9584 get_uleb128 (op1, readp, nexthdr);
9585 if ((uint64_t) (nexthdr - readp) < 1)
9587 get_uleb128 (op2, readp, nexthdr);
9609 if ((uint64_t) (nexthdr - readp) < 1)
9611 get_uleb128 (len, readp, nexthdr);
9612 if ((uint64_t) (nexthdr - readp) < len)
9615 address_size, offset_size, cu, len, readp);
9616 readp += len;
9620 if ((uint64_t) (nexthdr - readp) < 1)
9622 get_uleb128 (op1, readp, nexthdr);
9623 if ((uint64_t) (nexthdr - readp) < 1)
9625 get_uleb128 (op2, readp, nexthdr);
9637 if ((uint64_t) (nexthdr - readp) < 1)
9639 get_uleb128 (len, readp, nexthdr);
9640 if ((uint64_t) (nexthdr - readp) < len)
9643 address_size, offset_size, cu, len, readp);
9644 readp += len;
9648 if ((uint64_t) (nexthdr - readp) < 1)
9650 get_uleb128 (len, readp, nexthdr);
9651 if ((uint64_t) (nexthdr - readp) < len)
9654 address_size, offset_size, cu, len, readp);
9655 readp += len;
9661 if ((uint64_t) (nexthdr - readp) < 4)
9663 op1 = read_4ubyte_unaligned_inc (dbg, readp);
9667 if ((uint64_t) (nexthdr - readp) < 8)
9669 op1 = read_8ubyte_unaligned_inc (dbg, readp);
9684 if ((uint64_t) (nexthdr - readp) < 8)
9686 op1 = read_4ubyte_unaligned_inc (dbg, readp);
9687 op2 = read_4ubyte_unaligned_inc (dbg, readp);
9691 if ((uint64_t) (nexthdr - readp) < 16)
9693 op1 = read_8ubyte_unaligned_inc (dbg, readp);
9694 op2 = read_8ubyte_unaligned_inc (dbg, readp);
9705 if ((uint64_t) (nexthdr - readp) < 1)
9707 get_uleb128 (len, readp, nexthdr);
9708 if ((uint64_t) (nexthdr - readp) < len)
9711 address_size, offset_size, cu, len, readp);
9712 readp += len;
9718 if ((uint64_t) (nexthdr - readp) < 4)
9720 op1 = read_4ubyte_unaligned_inc (dbg, readp);
9724 if ((uint64_t) (nexthdr - readp) < 8)
9726 op1 = read_8ubyte_unaligned_inc (dbg, readp);
9728 if ((uint64_t) (nexthdr - readp) < 1)
9730 get_uleb128 (op2, readp, nexthdr);
9741 if ((uint64_t) (nexthdr - readp) < 1)
9743 get_uleb128 (len, readp, nexthdr);
9744 if ((uint64_t) (nexthdr - readp) < len)
9747 address_size, offset_size, cu, len, readp);
9748 readp += len;
9752 if ((uint64_t) (nexthdr - readp) < 1)
9754 get_uleb128 (op1, readp, nexthdr);
9755 if ((uint64_t) (nexthdr - readp) < 1)
9757 get_uleb128 (op2, readp, nexthdr);
9767 if (readp != nexthdr)
9769 size_t padding = nexthdr - readp;
9771 readp = nexthdr;
9805 unsigned char *readp = data->d_buf;
9808 while (readp < endp)
9810 ptrdiff_t offset = readp - (unsigned char *) data->d_buf;
9816 &cu, offset, &readp, endp, &attr))
9838 const unsigned char *locp = readp;
9866 readp = (unsigned char *) locendp;
9888 const unsigned char *locp = readp;
9889 const unsigned char *locendp = readp + data->d_size;
9942 readp = (unsigned char *) locp;
9946 begin = read_8ubyte_unaligned_inc (dbg, readp);
9947 end = read_8ubyte_unaligned_inc (dbg, readp);
9951 begin = read_4ubyte_unaligned_inc (dbg, readp);
9952 end = read_4ubyte_unaligned_inc (dbg, readp);
9979 uint_fast16_t len = read_2ubyte_unaligned_inc (dbg, readp);
9998 if (endp - readp <= (ptrdiff_t) len)
10006 address_size, offset_size, cu, len, readp);
10009 readp += len;
10109 const unsigned char *readp = (const unsigned char *) data->d_buf;
10110 const unsigned char *readendp = readp + data->d_size;
10113 while (readp < readendp)
10115 unsigned int opcode = *readp++;
10130 get_uleb128 (u128, readp, readendp);
10132 endp = memchr (readp, '\0', readendp - readp);
10143 level, "", (char *) readp, u128);
10146 level, "", (char *) readp, u128);
10148 printf (" #vendor-ext %s, number %u\n", (char *) readp, u128);
10150 readp = endp + 1;
10155 get_uleb128 (u128, readp, readendp);
10156 if (readendp - readp < 1)
10163 get_uleb128 (u128_2, readp, readendp);
10166 size_t macoff = readp - (const unsigned char *) data->d_buf;
10195 if (unlikely (opcode != 0 || readp != readendp))
10254 const unsigned char *readp = (const unsigned char *) data->d_buf;
10255 const unsigned char *readendp = readp + data->d_size;
10257 while (readp < readendp)
10260 (uint64_t) (readp - (const unsigned char *) data->d_buf));
10264 if (readp + 2 > readendp)
10270 const uint16_t vers = read_2ubyte_unaligned_inc (dbg, readp);
10281 if (readp + 1 > readendp)
10283 const unsigned char flag = *readp++;
10318 line_offset = read_8ubyte_unaligned_inc (dbg, readp);
10320 line_offset = read_4ubyte_unaligned_inc (dbg, readp);
10343 if (readp + 1 > readendp)
10345 unsigned int tlen = *readp++;
10350 if (readp + 1 > readendp)
10352 unsigned int opcode = *readp++;
10359 vendor[opcode - DW_MACRO_lo_user] = readp;
10360 if (readp + 1 > readendp)
10362 unsigned int args = *readp++;
10368 if (readp + 1 > readendp)
10370 unsigned int form = *readp++;
10387 if (readp + 1 > readendp)
10389 unsigned int opcode = *readp++;
10400 get_uleb128 (u128, readp, readendp);
10401 if (readp >= readendp)
10403 get_uleb128 (u128_2, readp, readendp);
10429 get_uleb128 (u128, readp, readendp);
10430 endp = memchr (readp, '\0', readendp - readp);
10434 level, "", readp, u128);
10435 readp = endp + 1;
10439 get_uleb128 (u128, readp, readendp);
10440 endp = memchr (readp, '\0', readendp - readp);
10444 level, "", readp, u128);
10445 readp = endp + 1;
10449 get_uleb128 (u128, readp, readendp);
10450 if (readp + offset_len > readendp)
10453 off = read_8ubyte_unaligned_inc (dbg, readp);
10455 off = read_4ubyte_unaligned_inc (dbg, readp);
10461 get_uleb128 (u128, readp, readendp);
10462 if (readp + offset_len > readendp)
10465 off = read_8ubyte_unaligned_inc (dbg, readp);
10467 off = read_4ubyte_unaligned_inc (dbg, readp);
10473 if (readp + offset_len > readendp)
10476 off = read_8ubyte_unaligned_inc (dbg, readp);
10478 off = read_4ubyte_unaligned_inc (dbg, readp);
10484 get_uleb128 (u128, readp, readendp);
10485 if (readp + offset_len > readendp)
10488 readp = print_form_data (dbg, DW_FORM_strp_sup,
10489 readp, readendp, offset_len,
10495 get_uleb128 (u128, readp, readendp);
10496 if (readp + offset_len > readendp)
10499 readp = print_form_data (dbg, DW_FORM_strp_sup,
10500 readp, readendp, offset_len,
10506 if (readp + offset_len > readendp)
10509 off = read_8ubyte_unaligned_inc (dbg, readp);
10511 off = read_4ubyte_unaligned_inc (dbg, readp);
10518 get_uleb128 (u128, readp, readendp);
10519 if (readp + offset_len > readendp)
10522 readp = print_form_data (dbg, DW_FORM_strx,
10523 readp, readendp, offset_len,
10529 get_uleb128 (u128, readp, readendp);
10530 if (readp + offset_len > readendp)
10533 readp = print_form_data (dbg, DW_FORM_strx,
10534 readp, readendp, offset_len,
10552 while (args > 0 && readp < readendp)
10555 readp = print_form_data (dbg, form, readp, readendp,
10564 if (readp + 1 > readendp)
10566 opcode = *readp++;
10678 const unsigned char *readp = start;
10682 while (readp < readendp)
10691 Dwarf_Off off = (Dwarf_Off) (readp
10752 unit_length = read_4ubyte_unaligned_inc (dbg, readp);
10755 if (unlikely (readp > readendp - 8))
10761 unit_length = read_8ubyte_unaligned_inc (dbg, readp);
10776 if (readp > readendp - 4
10778 || unit_length > (uint64_t) (readendp - readp))
10781 next_unitp = readp + unit_length;
10783 version = read_2ubyte_unaligned_inc (dbg, readp);
10792 padding = read_2ubyte_unaligned_inc (dbg, readp);
10796 && listptr->offset != (Dwarf_Off) (readp - start))
10806 size_t offsets = (next_unitp - readp) / offset_size;
10814 size_t index_offset = readp - (const unsigned char *) data->d_buf;
10816 while (readp <= next_unitp - offset_size)
10820 offset = read_4ubyte_unaligned_inc (dbg, readp);
10822 offset = read_8ubyte_unaligned_inc (dbg, readp);
10829 if (readp != next_unitp)
10831 (size_t) (next_unitp - readp));
10834 readp = next_unitp;
10860 const unsigned char *readp = data->d_buf;
10864 if (unlikely (readp + 4 > dataend))
10871 unsigned int version = *readp++;
10872 unsigned int eh_frame_ptr_enc = *readp++;
10873 unsigned int fde_count_enc = *readp++;
10874 unsigned int table_enc = *readp++;
10888 readp = read_encoded (eh_frame_ptr_enc, readp, dataend, &eh_frame_ptr,
10890 if (unlikely (readp == NULL))
10905 readp = read_encoded (fde_count_enc, readp, dataend, &fde_count, dbg);
10906 if (unlikely (readp == NULL))
10919 while (fde_count > 0 && readp + 8 <= dataend)
10921 int32_t initial_location = read_4sbyte_unaligned_inc (dbg, readp);
10924 int32_t address = read_4sbyte_unaligned_inc (dbg, readp);
10932 while (0 && readp < dataend)
10962 const unsigned char *readp = data->d_buf;
10963 const unsigned char *const dataend = readp + data->d_size;
10965 if (unlikely (readp + 1 > dataend))
10971 unsigned int lpstart_encoding = *readp++;
10977 readp = read_encoded (lpstart_encoding, readp, dataend, &lpstart, dbg);
10981 if (unlikely (readp + 1 > dataend))
10983 unsigned int ttype_encoding = *readp++;
10990 get_uleb128 (ttype_base_offset, readp, dataend);
10992 if ((size_t) (dataend - readp) > ttype_base_offset)
10993 ttype_base = readp + ttype_base_offset;
10996 if (unlikely (readp + 1 > dataend))
10998 unsigned int call_site_encoding = *readp++;
11002 get_uleb128 (call_site_table_len, readp, dataend);
11004 const unsigned char *const action_table = readp + call_site_table_len;
11009 while (readp < action_table)
11015 readp = read_encoded (call_site_encoding, readp, dataend,
11018 readp = read_encoded (call_site_encoding, readp, dataend,
11021 readp = read_encoded (call_site_encoding, readp, dataend,
11024 get_uleb128 (action, readp, dataend);
11032 if (readp != action_table)
11055 get_sleb128 (ar_filter, readp, action_table_end);
11059 if (readp >= action_table_end)
11061 get_sleb128 (ar_disp, readp, action_table_end);
11074 while (readp < action_table_end);
11106 readp = ttype_base - max_ar_filter * dsize;
11110 readp = read_encoded (ttype_encoding, readp, ttype_base, &ttype,
11114 while (readp < ttype_base);
11144 const unsigned char *readp = data->d_buf;
11145 const unsigned char *const dataend = readp + data->d_size;
11147 if (unlikely (readp + 4 > dataend))
11154 int32_t vers = read_4ubyte_unaligned (dbg, readp);
11168 readp += 4;
11169 if (unlikely (readp + 4 > dataend))
11172 uint32_t cu_off = read_4ubyte_unaligned (dbg, readp);
11175 readp += 4;
11176 if (unlikely (readp + 4 > dataend))
11179 uint32_t tu_off = read_4ubyte_unaligned (dbg, readp);
11182 readp += 4;
11183 if (unlikely (readp + 4 > dataend))
11186 uint32_t addr_off = read_4ubyte_unaligned (dbg, readp);
11189 readp += 4;
11190 if (unlikely (readp + 4 > dataend))
11193 uint32_t sym_off = read_4ubyte_unaligned (dbg, readp);
11196 readp += 4;
11197 if (unlikely (readp + 4 > dataend))
11200 uint32_t const_off = read_4ubyte_unaligned (dbg, readp);
11207 readp = data->d_buf + cu_off;
11213 size_t cu_nr = (nextp - readp) / 16;
11220 while (dataend - readp >= 16 && n < cu_nr)
11222 uint64_t off = read_8ubyte_unaligned (dbg, readp);
11223 readp += 8;
11225 uint64_t len = read_8ubyte_unaligned (dbg, readp);
11226 readp += 8;
11233 readp = data->d_buf + tu_off;
11238 size_t tu_nr = (nextp - readp) / 24;
11245 while (dataend - readp >= 24 && n < tu_nr)
11247 uint64_t off = read_8ubyte_unaligned (dbg, readp);
11248 readp += 8;
11250 uint64_t type = read_8ubyte_unaligned (dbg, readp);
11251 readp += 8;
11253 uint64_t sig = read_8ubyte_unaligned (dbg, readp);
11254 readp += 8;
11262 readp = data->d_buf + addr_off;
11267 size_t addr_nr = (nextp - readp) / 20;
11274 while (dataend - readp >= 20 && n < addr_nr)
11276 uint64_t low = read_8ubyte_unaligned (dbg, readp);
11277 readp += 8;
11279 uint64_t high = read_8ubyte_unaligned (dbg, readp);
11280 readp += 8;
11282 uint32_t idx = read_4ubyte_unaligned (dbg, readp);
11283 readp += 4;
11297 readp = data->d_buf + sym_off;
11299 size_t sym_nr = (nextp - readp) / 8;
11306 while (dataend - readp >= 8 && n < sym_nr)
11308 uint32_t name = read_4ubyte_unaligned (dbg, readp);
11309 readp += 4;
11311 uint32_t vector = read_4ubyte_unaligned (dbg, readp);
11312 readp += 4;