Lines Matching refs:segment
490 // the segment headers.
766 // Return an output segment of type TYPE, with segment flags SET set
767 // and segment flags CLEAR clear. Return NULL if there is none.
1274 // Maps section SECN to SEGMENT s.
1623 // Map section flags to segment flags.
1638 // appear in the output segment. IS_RELRO is true if this is a relro
1805 // output segment. This function captures a lot of the ideas in
1886 // Attach an output section to a segment.
1897 // Attach an allocated output section to a segment.
1916 // This output section goes into a PT_LOAD segment.
1920 // If this output section's segment has extra flags that need to be set,
1931 // Large data sections also go into their own PT_LOAD segment.
1989 // Check if segment should be marked unique. For segments marked
2000 // segment.
2003 // See if we already have an equivalent PT_NOTE segment.
2026 // segment. There can only be one such segment.
2035 // PT_GNU_RELRO segment. There can only be one such segment.
2045 // segment. This seems broken to me, but this is what GNU ld does,
2054 "may cause confusing PT_INTERP segment"));
2104 // executable as a PT_GNU_STACK segment. If an object file does not
2105 // have a .note.GNU-stack segment, we must assume that it is an old
2256 // Find the first read-only PT_LOAD segment, creating one if
2298 Output_segment* segment = *p;
2300 Output_segment* copy = new Output_segment(*segment);
2301 (*segment_states)[segment] = copy;
2305 // Restore states of output segments and delete any segment not found in
2311 // Go through the segment list and remove any segment added in the
2318 Output_segment* segment = *list_iter;
2320 segment_states->find(segment);
2325 *segment = *copy;
2327 // Also fix up TLS and RELRO segment pointers as appropriate.
2328 if (segment->type() == elfcpp::PT_TLS)
2329 this->tls_segment_ = segment;
2330 else if (segment->type() == elfcpp::PT_GNU_RELRO)
2331 this->relro_segment_ = segment;
2338 // This is a segment created during section layout. It should be
2340 delete segment;
2410 // Save segment states.
2428 // If the user set the address of the text segment, that may not be
2429 // compatible with putting the segment headers and file headers into
2430 // that segment. For isolate_execinstr() targets, it's the rodata
2431 // segment rather than text where we might put the headers.
2455 // a copy of the segment list right before the relaxation loop and use
2460 // PLOAD_SEG is the address of a pointer for the load segment.
2461 // PHDR_SEG is a pointer to the PHDR segment.
2462 // SEGMENT_HEADERS points to the output segment header.
2506 // If the address of the load segment we found has been set by
2533 // Lay out the segment headers.
2659 // 1) Finalize the list of output segments and create the segment
2701 // Create the PT_PHDR segment which will hold the program
2717 // interpreter, and put it in a PT_INTERP segment. Don't do it
2725 // it in a PT_DYNAMIC segment.
2742 // Create segment headers.
2781 // Check if data segment size is less than the safe value with PIE links.
2792 // With -Wl,--rosegment, note the end addr of "R E" segment.
2812 // With -Wl,--rosegment, report data segment size as delta of end of
2813 // "RW" segment and end of "R E" segment. Otherwise, data segment
2814 // size is just the memsz of "RW" segment.
2822 _("Unsafe PIE data segment size (%" PRIu64 " > %" PRIu64 "). "
2825 "range immediately below mm->mmap_base. The first PT_LOAD segment "
2826 "is mapped below mm->mmap_base, the subsequent PT_LOAD segment(s) "
2831 "up mapping part of their data segment over their stack resulting "
2832 "in corruption of the stack. Any PIE binary with a data segment > "
2838 // If there is a load segment that contains the file and program headers,
3050 // library, we create a PT_GNU_STACK segment.
3305 // is based entirely on the segment type and flags. When this is
3306 // called the segment addresses have normally not yet been set.
3315 // The single PT_PHDR segment is required to precede any loadable
3316 // segment. We simply make it always first.
3325 // The single PT_INTERP segment is required to precede any loadable
3326 // segment. We simply make it always second.
3341 // We put the PT_TLS segment last except for the PT_GNU_RELRO
3342 // segment, because that is where the dynamic linker expects to find
3354 // We put the PT_GNU_RELRO segment last, because that is where the
3366 // by the numeric segment type and flags values. There should not
3367 // be more than one segment with the same type and flags, except
3404 // A segment which holds large data comes after a segment which does
3418 // the unlikely case of a non-readable segment comes before the
3419 // normal case of a readable segment. If there are multiple
3456 // On targets where the text segment contains only executable code,
3457 // a non-executable segment is never the text segment.
3497 // If LOAD_SEG is NULL, then the file header and segment headers
3530 // When we hit the segment that should contain the
3547 // Verify that the file headers fall into the first segment.
3605 // decision once we know the size of the segment.
3614 // This is the segment that will contain the file
3619 // text segment to the read-only segment, move up now.
3627 // But this is not the first segment! To make its
3646 // the maximum segment alignment is larger than the page size.
3654 // us from using a load segment. We need to ensure that
3656 // segment. This is because the linker script
3673 // Now that we know the size of this segment, we may be able
3677 // the ABI mandated page size. If the segment has been
3731 gold_error(_("load segment overlap [0x%llx -> 0x%llx] and "
3786 // Set the TLS offsets for each section in the PT_TLS segment.
3834 // segment.
3923 // segment.
3943 // program segment which should hold the file header and segment
3945 // segment.
4655 // Create the .interp section and PT_INTERP segment.
4786 // Finish the .dynamic section and PT_DYNAMIC segment.
4909 // We don't know the section -> segment mapping, so we are
4947 gold_error(_("read-only segment has dynamic relocations"));
4950 gold_warning(_("shared library text segment is not shareable"));
5305 // Create an output segment.
