Lines Matching defs:data
99 "input data"), 0 },
145 N_("Do not find symbol names for addresses in DWARF data"), 0 },
147 N_("Display just offsets instead of resolving values to addresses in DWARF data"), 0 },
151 N_("Show compression information for compressed sections (when used with -S); decompress section before dumping data (when used with -p or -x)"), 0 },
218 /* True if the architecture specific data should be printed. */
636 /* Create a file descriptor to read the data from the
695 Elf_Data *data = elf_rawdata (scn, NULL);
696 if (data == NULL)
704 section data in to create a file descriptor for it. */
720 ssize_t size = data->d_size;
721 if (write_retry (sfd, data->d_buf, size) != size)
723 error (0, 0, _("cannot write section data"));
860 This takes care of applying relocations to DWARF data in ET_REL files. */
1605 /* Get the data of the section. */
1606 Elf_Data *data = elf_getdata (scn, NULL);
1613 if (data == NULL || data->d_size < sizeof (Elf32_Word) || symshdr == NULL
1622 Elf32_Word *grpref = (Elf32_Word *) data->d_buf;
1632 data->d_size / sizeof (Elf32_Word) - 1)
1636 data->d_size / sizeof (Elf32_Word) - 1),
1642 data->d_size / sizeof (Elf32_Word) - 1);
1644 for (size_t cnt = 1; cnt < data->d_size / sizeof (Elf32_Word); ++cnt)
1825 Elf_Data *data;
1830 /* Get the data of the section. */
1832 data = elf_getdata_rawchunk(ebl->elf, phdr->p_offset,
1835 data = elf_getdata (scn, NULL);
1837 if (data == NULL)
1841 dyn_ents = get_dyn_ents (data);
1892 GElf_Dyn *dyn = gelf_getdyn (data, cnt, &dynmem);
2052 /* Get the data of the section. */
2053 Elf_Data *data = elf_getdata (scn, NULL);
2054 if (data == NULL)
2122 GElf_Rel *rel = gelf_getrel (data, cnt, &relmem);
2241 /* Get the data of the section. */
2242 Elf_Data *data = elf_getdata (scn, NULL);
2243 if (data == NULL)
2311 GElf_Rela *rel = gelf_getrela (data, cnt, &relmem);
2486 /* Get the data of the section. */
2487 Elf_Data *data = elf_getdata (scn, NULL);
2488 if (data == NULL)
2502 /* Bingo, found the version information. Now get the data. */
2536 unsigned int nsyms = data->d_size / (class == ELFCLASS32
2566 GElf_Sym *sym = gelf_getsymshndx (data, xndx_data, cnt, &sym_mem, &xndx);
2783 /* Get the data of the section. */
2784 Elf_Data *data = elf_getdata (scn, NULL);
2785 if (data == NULL)
2815 /* Get the data at the next offset. */
2817 GElf_Verneed *need = gelf_getverneed (data, offset, &needmem);
2830 GElf_Vernaux *aux = gelf_getvernaux (data, auxoffset, &auxmem);
2858 /* Get the data of the section. */
2859 Elf_Data *data = elf_getdata (scn, NULL);
2860 if (data == NULL)
2892 /* Get the data at the next offset. */
2894 GElf_Verdef *def = gelf_getverdef (data, offset, &defmem);
2900 GElf_Verdaux *aux = gelf_getverdaux (data, auxoffset, &auxmem);
2915 aux = gelf_getverdaux (data, auxoffset, &auxmem);
2944 /* Get the data of the section. */
2945 Elf_Data *data = elf_getdata (scn, NULL);
2946 if (data == NULL)
3002 /* Get the data at the next offset. */
3036 /* Get the data at the next offset. */
3075 /* Run through the data structures again and collect the strings. */
3096 /* Get the data at the next offset. */
3130 /* Get the data at the next offset. */
3199 GElf_Versym *sym = gelf_getversym (data, cnt, &symmem);
3314 Elf_Data *data = elf_getdata (scn, NULL);
3315 if (unlikely (data == NULL))
3317 error (0, 0, _("cannot get data for section %d: %s"),
3322 if (unlikely (data->d_size < 2 * sizeof (Elf32_Word)))
3325 error (0, 0, _("invalid data in sysv.hash section %d"),
3330 Elf32_Word nbucket = ((Elf32_Word *) data->d_buf)[0];
3331 Elf32_Word nchain = ((Elf32_Word *) data->d_buf)[1];
3334 if (used_buf > data->d_size)
3337 Elf32_Word *bucket = &((Elf32_Word *) data->d_buf)[2];
3338 Elf32_Word *chain = &((Elf32_Word *) data->d_buf)[2 + nbucket];
3378 Elf_Data *data = elf_getdata (scn, NULL);
3379 if (unlikely (data == NULL))
3381 error (0, 0, _("cannot get data for section %d: %s"),
3386 if (unlikely (data->d_size < 2 * sizeof (Elf64_Xword)))
3389 error (0, 0, _("invalid data in sysv.hash64 section %d"),
3394 Elf64_Xword nbucket = ((Elf64_Xword *) data->d_buf)[0];
3395 Elf64_Xword nchain = ((Elf64_Xword *) data->d_buf)[1];
3397 uint64_t maxwords = data->d_size / sizeof (Elf64_Xword);
3403 Elf64_Xword *bucket = &((Elf64_Xword *) data->d_buf)[2];
3404 Elf64_Xword *chain = &((Elf64_Xword *) data->d_buf)[2 + nbucket];
3444 Elf_Data *data = elf_getdata (scn, NULL);
3445 if (unlikely (data == NULL))
3447 error (0, 0, _("cannot get data for section %d: %s"),
3452 if (unlikely (data->d_size < 4 * sizeof (Elf32_Word)))
3456 error (0, 0, _("invalid data in gnu.hash section %d"),
3461 Elf32_Word nbucket = ((Elf32_Word *) data->d_buf)[0];
3462 Elf32_Word symbias = ((Elf32_Word *) data->d_buf)[1];
3468 Elf32_Word bitmask_words = ((Elf32_Word *) data->d_buf)[2];
3475 Elf32_Word shift = ((Elf32_Word *) data->d_buf)[3];
3480 uint32_t max_nsyms = (data->d_size - used_buf) / sizeof (Elf32_Word);
3481 if (used_buf > data->d_size)
3486 Elf32_Word *bitmask = &((Elf32_Word *) data->d_buf)[4];
3487 Elf32_Word *bucket = &((Elf32_Word *) data->d_buf)[4 + bitmask_words];
3488 Elf32_Word *chain = &((Elf32_Word *) data->d_buf)[4 + bitmask_words
3617 Elf_Data *data = elf_getdata (scn, NULL);
3618 if (data == NULL)
3627 GElf_Lib *lib = gelf_getlib (data, cnt, &lib_mem);
3649 left (Elf_Data *data,
3652 return (const unsigned char *) data->d_buf + data->d_size - p;
3688 Elf_Data *data = elf_rawdata (scn, NULL);
3689 if (unlikely (data == NULL || data->d_size == 0))
3692 const unsigned char *p = data->d_buf;
3701 while (left (data, p) >= 4)
3710 if (unlikely (len > left (data, p)))
4392 const unsigned char *data = block;
4394 printf (" %02x", *data++);
4440 struct Dwarf_CU *cu, Dwarf_Word len, const unsigned char *data)
4456 uint_fast8_t op = *data++;
4476 addr = read_4ubyte_unaligned (dbg, data);
4478 addr = read_8ubyte_unaligned (dbg, data);
4481 data += addrsize;
4499 addr = read_4ubyte_unaligned (dbg, data);
4501 addr = read_8ubyte_unaligned (dbg, data);
4502 data += ref_size;
4519 op_name, *((uint8_t *) data));
4520 ++data;
4530 op_name, read_2ubyte_unaligned (dbg, data));
4532 data += 2;
4541 op_name, read_4ubyte_unaligned (dbg, data));
4543 data += 4;
4552 op_name, (uint64_t) read_8ubyte_unaligned (dbg, data));
4554 data += 8;
4563 op_name, *((int8_t *) data));
4564 ++data;
4574 op_name, read_2sbyte_unaligned (dbg, data));
4576 data += 2;
4585 op_name, read_4sbyte_unaligned (dbg, data));
4587 data += 4;
4596 op_name, read_8sbyte_unaligned (dbg, data));
4598 data += 8;
4606 const unsigned char *start = data;
4609 get_uleb128 (uleb, data, data + len);
4612 CONSUME (data - start);
4613 offset += 1 + (data - start);
4620 start = data;
4622 get_uleb128 (uleb, data, data + len);
4625 CONSUME (data - start);
4626 offset += 1 + (data - start);
4637 start = data;
4640 get_uleb128 (uleb, data, data + len);
4642 get_uleb128 (uleb2, data, data + len);
4645 CONSUME (data - start);
4646 offset += 1 + (data - start);
4652 start = data;
4655 get_sleb128 (sleb, data, data + len);
4658 CONSUME (data - start);
4659 offset += 1 + (data - start);
4663 start = data;
4665 get_uleb128 (uleb, data, data + len);
4667 get_sleb128 (sleb, data, data + len);
4670 CONSUME (data - start);
4671 offset += 1 + (data - start);
4678 read_2ubyte_unaligned (dbg, data));
4680 data += 2;
4688 read_4ubyte_unaligned (dbg, data));
4690 data += 4;
4699 (uintmax_t) (offset + read_2sbyte_unaligned (dbg, data) + 3));
4701 data += 2;
4706 start = data;
4708 get_uleb128 (uleb, data, data + len);
4712 print_block (uleb, data);
4713 data += uleb;
4714 CONSUME (data - start);
4715 offset += 1 + (data - start);
4721 start = data;
4726 addr = read_4ubyte_unaligned (dbg, data);
4728 addr = read_8ubyte_unaligned (dbg, data);
4729 data += ref_size;
4732 get_sleb128 (sleb, data, data + len);
4737 CONSUME (data - start);
4738 offset += 1 + (data - start);
4744 start = data;
4746 get_uleb128 (uleb, data, data + len);
4751 addrsize, offset_size, cu, uleb, data);
4752 data += uleb;
4753 CONSUME (data - start);
4754 offset += 1 + (data - start);
4761 start = data;
4763 get_uleb128 (uleb, data, data + len);
4767 uint8_t usize = *(uint8_t *) data++;
4771 print_block (usize, data);
4772 data += usize;
4773 CONSUME (data - start);
4774 offset += 1 + (data - start);
4781 start = data;
4783 get_uleb128 (uleb, data, data + len);
4785 get_uleb128 (uleb2, data, data + len);
4790 CONSUME (data - start);
4791 offset += 1 + (data - start);
4798 start = data;
4800 usize = *(uint8_t *) data++;
4802 get_uleb128 (uleb, data, data + len);
4808 CONSUME (data - start);
4809 offset += 1 + (data - start);
4814 start = data;
4816 usize = *(uint8_t *) data++;
4818 get_uleb128 (uleb, data, data + len);
4822 CONSUME (data - start);
4823 offset += 1 + (data - start);
4832 start = data;
4834 get_uleb128 (uleb, data, data + len);
4839 CONSUME (data - start);
4840 offset += 1 + (data - start);
4847 uintmax_t param_off = (uintmax_t) read_4ubyte_unaligned (dbg, data);
4853 data += 4;
4906 Elf_Data *data = elf_getdata_rawchunk(
4912 GElf_Dyn *dyn = gelf_getdyn(data, dyn_idx, &dyn_mem);
4954 /* Use dynamic segment to get data for the string table section. */
5307 Dwarf_Sword data;
5310 &data, &enoffset) == 0)
5315 printf (" (%" PRId64 ")", data);
5340 Elf_Data *data = (dbg->sectiondata[IDX_debug_addr]
5342 if (unlikely (data == NULL))
5344 error (0, 0, _("cannot get .debug_addr section data: %s"),
5352 const unsigned char *start = (const unsigned char *) data->d_buf;
5354 const unsigned char *readendp = ((const unsigned char *) data->d_buf
5355 + data->d_size);
5367 - (const unsigned char *) data->d_buf);
5411 if (listptr->offset < off || listptr->offset > data->d_size)
5432 if (next_off < off || next_off > data->d_size)
5462 error (0, 0, "Invalid data");
5474 the section data. */
5529 size_t index_offset = readp - (const unsigned char *) data->d_buf;
5630 Elf_Data *data = (dbg->sectiondata[IDX_debug_aranges]
5633 if (unlikely (data == NULL))
5645 const unsigned char *readp = data->d_buf;
5646 const unsigned char *readendp = readp + data->d_size;
5651 size_t start_offset = hdrstart - (const unsigned char *) data->d_buf;
5657 error (0, 0, _("invalid data in section [%zu] '%s'"),
5812 Elf_Data *data =(dbg->sectiondata[IDX_debug_rnglists]
5814 if (unlikely (data == NULL))
5825 const unsigned char *readp = data->d_buf;
5826 const unsigned char *const dataend = ((unsigned char *) data->d_buf
5827 + data->d_size);
5833 error (0, 0, _("invalid data in section [%zu] '%s'"),
5838 ptrdiff_t offset = readp - (unsigned char *) data->d_buf;
5856 the section data. */
5902 (Dwarf_Off) (nexthdr - (unsigned char *) data->d_buf),
5935 - (unsigned char *) data->d_buf));
5968 (uint64_t) (readp - (unsigned char *) data->d_buf - 1),
5985 error (0, 0, _("invalid range list data"));
6183 Elf_Data *data = (dbg->sectiondata[IDX_debug_ranges]
6185 if (unlikely (data == NULL))
6204 unsigned char *const endp = (unsigned char *) data->d_buf + data->d_size;
6205 unsigned char *readp = data->d_buf;
6209 ptrdiff_t offset = readp - (unsigned char *) data->d_buf;
6232 if (unlikely (data->d_size - offset < (size_t) address_size * 2))
6791 Elf_Data *data = (is_eh_frame
6796 if (unlikely (data == NULL))
6824 const unsigned char *readp = data->d_buf;
6825 const unsigned char *const dataend = ((unsigned char *) data->d_buf
6826 + data->d_size);
6832 error (0, 0, _("invalid data in section [%zu] '%s'"),
6839 ptrdiff_t offset = readp - (unsigned char *) data->d_buf;
6864 ptrdiff_t start = readp - (unsigned char *) data->d_buf;
6920 /* In some variant for unwind data there is another field. */
6960 const char *hdr = "Augmentation data:";
7045 /* Initialize from CIE data. */
7068 + (base - (const unsigned char *) data->d_buf)
7081 + (base - (const unsigned char *) data->d_buf)
7116 const char *hdr = "Augmentation data:";
7744 print_block (block.length, block.data);
7780 attrp->cu, block.length, block.data);
7783 print_block (block.length, block.data);
7791 const unsigned char *readp = block.data;
7873 print_block (block.length, block.data);
8320 Elf_Data *data;
8328 error (0, 0, "invalid data");
8442 data = dbg->sectiondata[IDX_debug_str];
8444 data = dbg->sectiondata[IDX_debug_line_str];
8448 data = alt != NULL ? alt->sectiondata[IDX_debug_str] : NULL;
8450 if (data == NULL || val >= data->d_size
8451 || memchr (data->d_buf + val, '\0', data->d_size - val) == NULL)
8454 str = (char *) data->d_buf + val;
8474 data = dbg->sectiondata[IDX_debug_str_offsets];
8475 if (data == NULL
8476 || data->d_size - str_offsets_base < val)
8480 const unsigned char *strreadp = data->d_buf + str_offsets_base + val;
8481 const unsigned char *strreadendp = data->d_buf + data->d_size;
8492 data = dbg->sectiondata[IDX_debug_str];
8493 if (data == NULL || idx >= data->d_size
8494 || memchr (data->d_buf + idx, '\0',
8495 data->d_size - idx) == NULL)
8498 str = (char *) data->d_buf + idx;
8573 Elf_Data *data = (dbg->sectiondata[IDX_debug_line]
8575 if (unlikely (data == NULL))
8577 error (0, 0, _("cannot get line data section data: %s"),
8582 const unsigned char *linep = (const unsigned char *) data->d_buf;
8586 < (lineendp = (const unsigned char *) data->d_buf + data->d_size))
8588 size_t start_offset = linep - (const unsigned char *) data->d_buf;
8601 error (0, 0, _("invalid data in section [%zu] '%s'"),
8729 _("invalid data at offset %tu in section [%zu] '%s'"),
8730 linep - (const unsigned char *) data->d_buf,
8965 size_t offset = linep - (const unsigned char *) data->d_buf;
9297 /* There must only be one data block. */
9298 assert (elf_getdata (scn, data) == NULL);
9314 Elf_Data *data = (dbg->sectiondata[IDX_debug_loclists]
9316 if (unlikely (data == NULL))
9327 const unsigned char *readp = data->d_buf;
9328 const unsigned char *const dataend = ((unsigned char *) data->d_buf
9329 + data->d_size);
9335 error (0, 0, _("invalid data in section [%zu] '%s'"),
9340 ptrdiff_t offset = readp - (unsigned char *) data->d_buf;
9358 the section data. */
9404 (Dwarf_Off) (nexthdr - (unsigned char *) data->d_buf),
9437 - (unsigned char *) data->d_buf));
9459 Dwarf_Off off = (Dwarf_Off) (readp - (unsigned char *) data->d_buf);
9469 data->d_buf)))
9472 locendp = (const unsigned char *) data->d_buf + next_off;
9475 (uint64_t) (readp - (unsigned char *) data->d_buf),
9507 (uint64_t) (readp - (unsigned char *) data->d_buf - 1),
9524 error (0, 0, _("invalid loclists data"));
9782 Elf_Data *data = (dbg->sectiondata[IDX_debug_loc]
9785 if (unlikely (data == NULL))
9805 unsigned char *readp = data->d_buf;
9806 unsigned char *const endp = (unsigned char *) data->d_buf + data->d_size;
9810 ptrdiff_t offset = readp - (unsigned char *) data->d_buf;
9842 - (const unsigned char *) data->d_buf))
9845 locendp = (const unsigned char *) data->d_buf + next_off;
9876 && unlikely (data->d_size - offset < (size_t) address_size * 2))
9889 const unsigned char *locendp = readp + data->d_size;
10051 Elf_Data *data = (dbg->sectiondata[IDX_debug_macinfo]
10053 if (unlikely (data == NULL))
10055 error (0, 0, _("cannot get macro information section data: %s"),
10093 cus[nculist].offset = data->d_size;
10109 const unsigned char *readp = (const unsigned char *) data->d_buf;
10110 const unsigned char *readendp = readp + data->d_size;
10166 size_t macoff = readp - (const unsigned char *) data->d_buf;
10168 if (macoff >= cus[0].offset && cus[0].offset != data->d_size)
10170 while (macoff >= cus[1].offset && cus[1].offset != data->d_size)
10215 Elf_Data *data = elf_getdata (scn, NULL);
10216 if (unlikely (data == NULL))
10218 error (0, 0, _("cannot get macro information section data: %s"),
10254 const unsigned char *readp = (const unsigned char *) data->d_buf;
10255 const unsigned char *readendp = readp + data->d_size;
10260 (uint64_t) (readp - (const unsigned char *) data->d_buf));
10267 error (0, 0, _("invalid data"));
10612 Elf_Data *data = elf_rawdata (scn, NULL);
10613 const size_t sh_size = data ? data->d_size : 0;
10636 const char *str = (const char *) data->d_buf + offset;
10665 Elf_Data *data = (dbg->sectiondata[IDX_debug_str_offsets]
10667 if (unlikely (data == NULL))
10669 error (0, 0, _("cannot get .debug_str_offsets section data: %s"),
10677 const unsigned char *start = (const unsigned char *) data->d_buf;
10679 const unsigned char *readendp = ((const unsigned char *) data->d_buf
10680 + data->d_size);
10692 - (const unsigned char *) data->d_buf);
10758 error (0, 0, "Invalid data");
10775 beyond the section data. */
10814 size_t index_offset = readp - (const unsigned char *) data->d_buf;
10851 Elf_Data *data = elf_rawdata (scn, NULL);
10853 if (unlikely (data == NULL))
10860 const unsigned char *readp = data->d_buf;
10861 const unsigned char *const dataend = ((unsigned char *) data->d_buf
10862 + data->d_size);
10867 error (0, 0, _("invalid data"));
10953 Elf_Data *data = elf_rawdata (scn, NULL);
10955 if (unlikely (data == NULL))
10962 const unsigned char *readp = data->d_buf;
10963 const unsigned char *const dataend = readp + data->d_size;
10968 error (0, 0, _("invalid data"));
11103 > (size_t) (ttype_base - (const unsigned char *) data->d_buf) / dsize)
11131 Elf_Data *data = elf_rawdata (scn, NULL);
11133 if (unlikely (data == NULL))
11144 const unsigned char *readp = data->d_buf;
11145 const unsigned char *const dataend = readp + data->d_size;
11150 error (0, 0, _("invalid data"));
11203 if (unlikely ((size_t) (dataend - (const unsigned char *) data->d_buf)
11207 readp = data->d_buf + cu_off;
11209 const unsigned char *nextp = data->d_buf + tu_off;
11210 if (tu_off >= data->d_size)
11233 readp = data->d_buf + tu_off;
11234 nextp = data->d_buf + addr_off;
11235 if (addr_off >= data->d_size)
11262 readp = data->d_buf + addr_off;
11263 nextp = data->d_buf + sym_off;
11264 if (sym_off >= data->d_size)
11293 const unsigned char *const_start = data->d_buf + const_off;
11294 if (const_off >= data->d_size)
11297 readp = data->d_buf + sym_off;
11784 void *value, const void *data, size_t size)
11796 .d_buf = (void *) data,
11805 error_exit (0, _("cannot convert core note data: %s"),
11808 return data + indata.d_size;
11832 void *data = alloca (count * sizeof (value_t));
11836 GElf_##Name *value_##Name __attribute__((unused)) = data
11846 data = alloca (*repeated_size);
11855 convert (core, item->type, count, data, desc + item->offset, convsize);
11900 for (const unsigned int *i = data; (void *) i < data + count * size; ++i)
11913 for (unsigned int *i = data;
11914 (void *) i < data + count * size; i += 2)
11924 for (const unsigned int *i = data;
11925 (void *) i < data + count * size; ++i)
11927 unsigned int bit = ((void *) i - data) * 8;
12094 processes all the data of a note. FORMATs 'b' and 'B' have a special case
12103 /* If SIZE is not zero here there is some remaining data. But we do not
12146 /* This set of items consumed a certain amount of the note's data.
12147 If there is more data there, we have another unit of the same size.
12429 Elf_Data *data = elf_getdata_rawchunk (core, desc_pos, descsz, ELF_T_AUXV);
12430 if (data == NULL)
12432 error_exit (0, _("cannot convert core note data: %s"), elf_errmsg (-1));
12438 GElf_auxv_t *av = gelf_getauxv (data, i, &av_mem);
12540 Elf_Data *data = elf_getdata_rawchunk (core, desc_pos, descsz, ELF_T_BYTE);
12541 if (data == NULL)
12542 error_exit (0, _("cannot convert core note data: %s"), elf_errmsg (-1));
12544 unsigned char const *ptr = data->d_buf;
12545 unsigned char const *const end = data->d_buf + data->d_size;
12555 printf (" Not enough data in NT_SIGINFO note.\n");
12597 Elf_Data *data = elf_getdata_rawchunk (core, desc_pos, descsz, ELF_T_BYTE);
12598 if (data == NULL)
12599 error_exit (0, _("cannot convert core note data: %s"), elf_errmsg (-1));
12601 unsigned char const *ptr = data->d_buf;
12602 unsigned char const *const end = data->d_buf + data->d_size;
12609 printf (" Not enough data in NT_FILE note.\n");
12676 GElf_Off start, Elf_Data *data)
12680 if (data == NULL)
12687 while (offset < data->d_size
12688 && (offset = gelf_getnote (data, offset,
12691 const char *name = nhdr.n_namesz == 0 ? "" : data->d_buf + name_offset;
12692 const char *desc = data->d_buf + desc_offset;
12694 /* GNU Build Attributes are weird, they store most of their data
12696 prefix here, then use the rest later as data. */
12753 if (offset == data->d_size)
12759 data != NULL ? "garbage data" : elf_errmsg (-1));
12828 hex_dump (const uint8_t *data, size_t len)
12839 printf ("%02x ", data[pos + i]);
12841 printf ("%02x", data[pos + i]);
12848 unsigned char b = data[pos + i];
12861 printf (_("\nSection [%zu] '%s' has no data to dump.\n"),
12869 data size. */
12886 Elf_Data *data = elf_rawdata (scn, NULL);
12887 if (data == NULL)
12888 error (0, 0, _("cannot get data for section [%zu] '%s': %s"),
12892 if (data->d_size == shdr->sh_size)
12902 shdr->sh_size, data->d_size, shdr->sh_offset);
12903 hex_dump (data->d_buf, data->d_size);
12920 data size. */
12937 Elf_Data *data = elf_rawdata (scn, NULL);
12938 if (data == NULL)
12939 error (0, 0, _("cannot get data for section [%zu] '%s': %s"),
12943 if (data->d_size == shdr->sh_size)
12953 shdr->sh_size, data->d_size, shdr->sh_offset);
12955 const char *start = data->d_buf;
12956 const char *const limit = start + data->d_size;
12960 const size_t pos = start - (const char *) data->d_buf;