[BACK]Return to pe.em CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / external / gpl3 / binutils.old / dist / ld / emultempl

Annotation of src/external/gpl3/binutils.old/dist/ld/emultempl/pe.em, Revision 1.5.2.1

1.1       christos    1: # This shell script emits a C file. -*- C -*-
                      2: # It does some substitutions.
                      3: if [ -z "$MACHINE" ]; then
                      4:   OUTPUT_ARCH=${ARCH}
                      5: else
                      6:   OUTPUT_ARCH=${ARCH}:${MACHINE}
                      7: fi
                      8: rm -f e${EMULATION_NAME}.c
                      9: (echo;echo;echo;echo;echo)>e${EMULATION_NAME}.c # there, now line numbers match ;-)
                     10: fragment <<EOF
1.5.2.1 ! martin     11: /* Copyright (C) 1995-2018 Free Software Foundation, Inc.
1.1       christos   12:
                     13:    This file is part of the GNU Binutils.
                     14:
                     15:    This program is free software; you can redistribute it and/or modify
                     16:    it under the terms of the GNU General Public License as published by
                     17:    the Free Software Foundation; either version 3 of the License, or
                     18:    (at your option) any later version.
                     19:
                     20:    This program is distributed in the hope that it will be useful,
                     21:    but WITHOUT ANY WARRANTY; without even the implied warranty of
                     22:    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
                     23:    GNU General Public License for more details.
                     24:
                     25:    You should have received a copy of the GNU General Public License
                     26:    along with this program; if not, write to the Free Software
                     27:    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
                     28:    MA 02110-1301, USA.  */
                     29:
                     30:
                     31: /* For WINDOWS_NT */
                     32: /* The original file generated returned different default scripts depending
                     33:    on whether certain switches were set, but these switches pertain to the
                     34:    Linux system and that particular version of coff.  In the NT case, we
                     35:    only determine if the subsystem is console or windows in order to select
                     36:    the correct entry point by default. */
                     37:
                     38: #define TARGET_IS_${EMULATION_NAME}
                     39:
                     40: /* Do this before including bfd.h, so we prototype the right functions.  */
                     41:
                     42: #if defined(TARGET_IS_armpe) \
                     43:     || defined(TARGET_IS_arm_wince_pe)
                     44: #define bfd_arm_allocate_interworking_sections \
                     45:        bfd_${EMULATION_NAME}_allocate_interworking_sections
                     46: #define bfd_arm_get_bfd_for_interworking \
                     47:        bfd_${EMULATION_NAME}_get_bfd_for_interworking
                     48: #define bfd_arm_process_before_allocation \
                     49:        bfd_${EMULATION_NAME}_process_before_allocation
                     50: #endif
                     51:
                     52: #include "sysdep.h"
                     53: #include "bfd.h"
                     54: #include "bfdlink.h"
                     55: #include "getopt.h"
                     56: #include "libiberty.h"
                     57: #include "filenames.h"
                     58: #include "ld.h"
                     59: #include "ldmain.h"
                     60: #include "ldexp.h"
                     61: #include "ldlang.h"
                     62: #include "ldfile.h"
                     63: #include "ldemul.h"
                     64: #include <ldgram.h>
                     65: #include "ldlex.h"
                     66: #include "ldmisc.h"
                     67: #include "ldctor.h"
1.3       christos   68: #include "ldbuildid.h"
1.1       christos   69: #include "coff/internal.h"
                     70:
                     71: /* FIXME: See bfd/peXXigen.c for why we include an architecture specific
                     72:    header in generic PE code.  */
                     73: #include "coff/i386.h"
                     74: #include "coff/pe.h"
                     75:
1.3       christos   76: /* FIXME: These are BFD internal header files, and we should not be
1.1       christos   77:    using it here.  */
                     78: #include "../bfd/libcoff.h"
1.3       christos   79: #include "../bfd/libpei.h"
1.1       christos   80:
                     81: #include "deffile.h"
                     82: #include "pe-dll.h"
                     83: #include "safe-ctype.h"
                     84:
                     85: /* Permit the emulation parameters to override the default section
                     86:    alignment by setting OVERRIDE_SECTION_ALIGNMENT.  FIXME: This makes
                     87:    it seem that include/coff/internal.h should not define
                     88:    PE_DEF_SECTION_ALIGNMENT.  */
                     89: #if PE_DEF_SECTION_ALIGNMENT != ${OVERRIDE_SECTION_ALIGNMENT:-PE_DEF_SECTION_ALIGNMENT}
                     90: #undef PE_DEF_SECTION_ALIGNMENT
                     91: #define PE_DEF_SECTION_ALIGNMENT ${OVERRIDE_SECTION_ALIGNMENT}
                     92: #endif
                     93:
                     94: #if defined(TARGET_IS_i386pe) \
                     95:     || defined(TARGET_IS_shpe) \
                     96:     || defined(TARGET_IS_armpe) \
                     97:     || defined(TARGET_IS_arm_wince_pe)
                     98: #define DLL_SUPPORT
                     99: #endif
                    100:
                    101: #if defined(TARGET_IS_i386pe)
                    102: #define DEFAULT_PSEUDO_RELOC_VERSION 2
                    103: #else
                    104: #define DEFAULT_PSEUDO_RELOC_VERSION 1
                    105: #endif
                    106:
                    107: #if defined(TARGET_IS_i386pe) || ! defined(DLL_SUPPORT)
                    108: #define        PE_DEF_SUBSYSTEM                3
                    109: #else
                    110: #undef NT_EXE_IMAGE_BASE
                    111: #undef PE_DEF_SECTION_ALIGNMENT
                    112: #undef PE_DEF_FILE_ALIGNMENT
                    113: #define NT_EXE_IMAGE_BASE              0x00010000
                    114:
                    115: #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_wince_pe)
                    116: #define PE_DEF_SECTION_ALIGNMENT       0x00001000
                    117: #define        PE_DEF_SUBSYSTEM                9
                    118: #else
                    119: #define PE_DEF_SECTION_ALIGNMENT       0x00000400
                    120: #define        PE_DEF_SUBSYSTEM                2
                    121: #endif
                    122: #define PE_DEF_FILE_ALIGNMENT          0x00000200
                    123: #endif
                    124:
                    125: static struct internal_extra_pe_aouthdr pe;
                    126: static int dll;
                    127: static int pe_subsystem = ${SUBSYSTEM};
                    128: static flagword real_flags = 0;
                    129: static int support_old_code = 0;
                    130: static char * thumb_entry_symbol = NULL;
                    131: static lang_assignment_statement_type *image_base_statement = 0;
                    132: static unsigned short pe_dll_characteristics = 0;
1.3       christos  133: static bfd_boolean insert_timestamp = TRUE;
                    134: static const char *emit_build_id;
1.1       christos  135:
                    136: #ifdef DLL_SUPPORT
                    137: static int pe_enable_stdcall_fixup = -1; /* 0=disable 1=enable.  */
                    138: static char *pe_out_def_filename = NULL;
                    139: static int pe_enable_auto_image_base = 0;
1.3       christos  140: static unsigned long pe_auto_image_base = 0x61500000;
1.1       christos  141: static char *pe_dll_search_prefix = NULL;
                    142: #endif
                    143:
                    144: extern const char *output_filename;
                    145:
                    146: static int is_underscoring (void)
                    147: {
                    148:   int u = 0;
                    149:   if (pe_leading_underscore != -1)
                    150:     return pe_leading_underscore;
                    151:   if (!bfd_get_target_info ("${OUTPUT_FORMAT}", NULL, NULL, &u, NULL))
                    152:     bfd_get_target_info ("${RELOCATEABLE_OUTPUT_FORMAT}", NULL, NULL, &u, NULL);
                    153:
                    154:   if (u == -1)
                    155:     abort ();
                    156:   pe_leading_underscore = (u != 0 ? 1 : 0);
                    157:   return pe_leading_underscore;
                    158: }
                    159:
                    160: static void
                    161: gld_${EMULATION_NAME}_before_parse (void)
                    162: {
                    163:   is_underscoring ();
                    164:   ldfile_set_output_arch ("${OUTPUT_ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`);
                    165:   output_filename = "${EXECUTABLE_NAME:-a.exe}";
                    166: #ifdef DLL_SUPPORT
                    167:   input_flags.dynamic = TRUE;
                    168:   config.has_shared = 1;
                    169: EOF
                    170:
                    171: # Cygwin no longer wants these noisy warnings.  Other PE
                    172: # targets might like to consider adding themselves here.
1.3       christos  173: # See also the mail thread starting here for the reason why
                    174: # merge_rdata defaults to 0 for cygwin:
                    175: #  http://cygwin.com/ml/cygwin-apps/2013-04/msg00187.html
1.1       christos  176: case ${target} in
                    177:   *-*-cygwin*)
                    178:     default_auto_import=1
1.3       christos  179:     default_merge_rdata=0
1.1       christos  180:     ;;
                    181:   i[3-7]86-*-mingw* | x86_64-*-mingw*)
                    182:     default_auto_import=1
                    183:     default_merge_rdata=0
                    184:     ;;
                    185:   *)
                    186:     default_auto_import=-1
                    187:     default_merge_rdata=1
                    188:     ;;
                    189: esac
                    190:
                    191: fragment <<EOF
                    192:   link_info.pei386_auto_import = ${default_auto_import};
                    193:   /* Use by default version.  */
                    194:   link_info.pei386_runtime_pseudo_reloc = DEFAULT_PSEUDO_RELOC_VERSION;
                    195: #endif
                    196: }
                    197: 
                    198: /* Indicates if RDATA shall be merged into DATA when pseudo-relocation
                    199:    version 2 is used and auto-import is enabled.  */
                    200: #define MERGE_RDATA_V2 ${default_merge_rdata}
                    201:
                    202: /* PE format extra command line options.  */
                    203:
                    204: /* Used for setting flags in the PE header.  */
                    205: #define OPTION_BASE_FILE               (300  + 1)
                    206: #define OPTION_DLL                     (OPTION_BASE_FILE + 1)
                    207: #define OPTION_FILE_ALIGNMENT          (OPTION_DLL + 1)
                    208: #define OPTION_IMAGE_BASE              (OPTION_FILE_ALIGNMENT + 1)
                    209: #define OPTION_MAJOR_IMAGE_VERSION     (OPTION_IMAGE_BASE + 1)
                    210: #define OPTION_MAJOR_OS_VERSION                (OPTION_MAJOR_IMAGE_VERSION + 1)
                    211: #define OPTION_MAJOR_SUBSYSTEM_VERSION (OPTION_MAJOR_OS_VERSION + 1)
                    212: #define OPTION_MINOR_IMAGE_VERSION     (OPTION_MAJOR_SUBSYSTEM_VERSION + 1)
                    213: #define OPTION_MINOR_OS_VERSION                (OPTION_MINOR_IMAGE_VERSION + 1)
                    214: #define OPTION_MINOR_SUBSYSTEM_VERSION (OPTION_MINOR_OS_VERSION + 1)
                    215: #define OPTION_SECTION_ALIGNMENT       (OPTION_MINOR_SUBSYSTEM_VERSION + 1)
                    216: #define OPTION_STACK                   (OPTION_SECTION_ALIGNMENT + 1)
                    217: #define OPTION_SUBSYSTEM               (OPTION_STACK + 1)
                    218: #define OPTION_HEAP                    (OPTION_SUBSYSTEM + 1)
                    219: #define OPTION_SUPPORT_OLD_CODE                (OPTION_HEAP + 1)
                    220: #define OPTION_OUT_DEF                 (OPTION_SUPPORT_OLD_CODE + 1)
                    221: #define OPTION_EXPORT_ALL              (OPTION_OUT_DEF + 1)
                    222: #define OPTION_EXCLUDE_SYMBOLS         (OPTION_EXPORT_ALL + 1)
                    223: #define OPTION_EXCLUDE_ALL_SYMBOLS     (OPTION_EXCLUDE_SYMBOLS + 1)
                    224: #define OPTION_KILL_ATS                        (OPTION_EXCLUDE_ALL_SYMBOLS + 1)
                    225: #define OPTION_STDCALL_ALIASES         (OPTION_KILL_ATS + 1)
                    226: #define OPTION_ENABLE_STDCALL_FIXUP    (OPTION_STDCALL_ALIASES + 1)
                    227: #define OPTION_DISABLE_STDCALL_FIXUP   (OPTION_ENABLE_STDCALL_FIXUP + 1)
1.5.2.1 ! martin    228: #define OPTION_THUMB_ENTRY             (OPTION_DISABLE_STDCALL_FIXUP + 1)
1.1       christos  229: #define OPTION_WARN_DUPLICATE_EXPORTS  (OPTION_THUMB_ENTRY + 1)
                    230: #define OPTION_IMP_COMPAT              (OPTION_WARN_DUPLICATE_EXPORTS + 1)
                    231: #define OPTION_ENABLE_AUTO_IMAGE_BASE  (OPTION_IMP_COMPAT + 1)
                    232: #define OPTION_DISABLE_AUTO_IMAGE_BASE (OPTION_ENABLE_AUTO_IMAGE_BASE + 1)
                    233: #define OPTION_DLL_SEARCH_PREFIX       (OPTION_DISABLE_AUTO_IMAGE_BASE + 1)
                    234: #define OPTION_NO_DEFAULT_EXCLUDES     (OPTION_DLL_SEARCH_PREFIX + 1)
                    235: #define OPTION_DLL_ENABLE_AUTO_IMPORT  (OPTION_NO_DEFAULT_EXCLUDES + 1)
                    236: #define OPTION_DLL_DISABLE_AUTO_IMPORT (OPTION_DLL_ENABLE_AUTO_IMPORT + 1)
                    237: #define OPTION_ENABLE_EXTRA_PE_DEBUG   (OPTION_DLL_DISABLE_AUTO_IMPORT + 1)
                    238: #define OPTION_EXCLUDE_LIBS            (OPTION_ENABLE_EXTRA_PE_DEBUG + 1)
                    239: #define OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC \
                    240:                                        (OPTION_EXCLUDE_LIBS + 1)
                    241: #define OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC        \
                    242:                                        (OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC + 1)
1.5.2.1 ! martin    243: #define OPTION_LARGE_ADDRESS_AWARE     (OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC + 1)
1.3       christos  244: #define OPTION_DISABLE_LARGE_ADDRESS_AWARE \
1.5.2.1 ! martin    245:                                        (OPTION_LARGE_ADDRESS_AWARE + 1)
1.1       christos  246: #define OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V1      \
1.3       christos  247:                                        (OPTION_DISABLE_LARGE_ADDRESS_AWARE + 1)
1.1       christos  248: #define OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V2      \
                    249:                                        (OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V1 + 1)
                    250: #define OPTION_EXCLUDE_MODULES_FOR_IMPLIB \
                    251:                                        (OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V2 + 1)
                    252: #define OPTION_USE_NUL_PREFIXED_IMPORT_TABLES \
                    253:                                        (OPTION_EXCLUDE_MODULES_FOR_IMPLIB + 1)
1.5.2.1 ! martin    254: #define OPTION_NO_LEADING_UNDERSCORE   (OPTION_USE_NUL_PREFIXED_IMPORT_TABLES + 1)
        !           255: #define OPTION_LEADING_UNDERSCORE      (OPTION_NO_LEADING_UNDERSCORE + 1)
1.1       christos  256: #define OPTION_ENABLE_LONG_SECTION_NAMES \
                    257:                                        (OPTION_LEADING_UNDERSCORE + 1)
                    258: #define OPTION_DISABLE_LONG_SECTION_NAMES \
                    259:                                        (OPTION_ENABLE_LONG_SECTION_NAMES + 1)
1.3       christos  260: /* DLLCharacteristics flags.  */
1.1       christos  261: #define OPTION_DYNAMIC_BASE            (OPTION_DISABLE_LONG_SECTION_NAMES + 1)
                    262: #define OPTION_FORCE_INTEGRITY         (OPTION_DYNAMIC_BASE + 1)
                    263: #define OPTION_NX_COMPAT               (OPTION_FORCE_INTEGRITY + 1)
1.3       christos  264: #define OPTION_NO_ISOLATION            (OPTION_NX_COMPAT + 1)
1.1       christos  265: #define OPTION_NO_SEH                  (OPTION_NO_ISOLATION + 1)
                    266: #define OPTION_NO_BIND                 (OPTION_NO_SEH + 1)
                    267: #define OPTION_WDM_DRIVER              (OPTION_NO_BIND + 1)
                    268: #define OPTION_TERMINAL_SERVER_AWARE   (OPTION_WDM_DRIVER + 1)
1.3       christos  269: /* Determinism.  */
                    270: #define OPTION_INSERT_TIMESTAMP                (OPTION_TERMINAL_SERVER_AWARE + 1)
                    271: #define OPTION_NO_INSERT_TIMESTAMP     (OPTION_INSERT_TIMESTAMP + 1)
                    272: #define OPTION_BUILD_ID                        (OPTION_NO_INSERT_TIMESTAMP + 1)
1.1       christos  273:
                    274: static void
                    275: gld${EMULATION_NAME}_add_options
                    276:   (int ns ATTRIBUTE_UNUSED,
                    277:    char **shortopts ATTRIBUTE_UNUSED,
                    278:    int nl,
                    279:    struct option **longopts,
                    280:    int nrl ATTRIBUTE_UNUSED,
                    281:    struct option **really_longopts ATTRIBUTE_UNUSED)
                    282: {
1.3       christos  283:   static const struct option xtra_long[] =
                    284:   {
                    285:     /* PE options.  */
1.1       christos  286:     {"base-file", required_argument, NULL, OPTION_BASE_FILE},
                    287:     {"dll", no_argument, NULL, OPTION_DLL},
                    288:     {"file-alignment", required_argument, NULL, OPTION_FILE_ALIGNMENT},
                    289:     {"heap", required_argument, NULL, OPTION_HEAP},
                    290:     {"image-base", required_argument, NULL, OPTION_IMAGE_BASE},
                    291:     {"major-image-version", required_argument, NULL, OPTION_MAJOR_IMAGE_VERSION},
                    292:     {"major-os-version", required_argument, NULL, OPTION_MAJOR_OS_VERSION},
                    293:     {"major-subsystem-version", required_argument, NULL, OPTION_MAJOR_SUBSYSTEM_VERSION},
                    294:     {"minor-image-version", required_argument, NULL, OPTION_MINOR_IMAGE_VERSION},
                    295:     {"minor-os-version", required_argument, NULL, OPTION_MINOR_OS_VERSION},
                    296:     {"minor-subsystem-version", required_argument, NULL, OPTION_MINOR_SUBSYSTEM_VERSION},
                    297:     {"section-alignment", required_argument, NULL, OPTION_SECTION_ALIGNMENT},
                    298:     {"stack", required_argument, NULL, OPTION_STACK},
                    299:     {"subsystem", required_argument, NULL, OPTION_SUBSYSTEM},
                    300:     {"support-old-code", no_argument, NULL, OPTION_SUPPORT_OLD_CODE},
                    301:     {"thumb-entry", required_argument, NULL, OPTION_THUMB_ENTRY},
                    302:     {"use-nul-prefixed-import-tables", no_argument, NULL,
                    303:      OPTION_USE_NUL_PREFIXED_IMPORT_TABLES},
                    304:     {"no-leading-underscore", no_argument, NULL, OPTION_NO_LEADING_UNDERSCORE},
                    305:     {"leading-underscore", no_argument, NULL, OPTION_LEADING_UNDERSCORE},
1.3       christos  306:     {"insert-timestamp", no_argument, NULL, OPTION_INSERT_TIMESTAMP},
                    307:     {"no-insert-timestamp", no_argument, NULL, OPTION_NO_INSERT_TIMESTAMP},
1.1       christos  308: #ifdef DLL_SUPPORT
                    309:     /* getopt allows abbreviations, so we do this to stop it
                    310:        from treating -o as an abbreviation for this option.  */
                    311:     {"output-def", required_argument, NULL, OPTION_OUT_DEF},
                    312:     {"output-def", required_argument, NULL, OPTION_OUT_DEF},
                    313:     {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL},
                    314:     {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMBOLS},
                    315:     {"exclude-all-symbols", no_argument, NULL, OPTION_EXCLUDE_ALL_SYMBOLS},
                    316:     {"exclude-libs", required_argument, NULL, OPTION_EXCLUDE_LIBS},
                    317:     {"exclude-modules-for-implib", required_argument, NULL, OPTION_EXCLUDE_MODULES_FOR_IMPLIB},
                    318:     {"kill-at", no_argument, NULL, OPTION_KILL_ATS},
                    319:     {"add-stdcall-alias", no_argument, NULL, OPTION_STDCALL_ALIASES},
                    320:     {"enable-stdcall-fixup", no_argument, NULL, OPTION_ENABLE_STDCALL_FIXUP},
                    321:     {"disable-stdcall-fixup", no_argument, NULL, OPTION_DISABLE_STDCALL_FIXUP},
                    322:     {"warn-duplicate-exports", no_argument, NULL, OPTION_WARN_DUPLICATE_EXPORTS},
                    323:     /* getopt() allows abbreviations, so we do this to stop it from
                    324:        treating -c as an abbreviation for these --compat-implib.  */
                    325:     {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT},
                    326:     {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT},
1.3       christos  327:     {"enable-auto-image-base", optional_argument, NULL, OPTION_ENABLE_AUTO_IMAGE_BASE},
1.1       christos  328:     {"disable-auto-image-base", no_argument, NULL, OPTION_DISABLE_AUTO_IMAGE_BASE},
                    329:     {"dll-search-prefix", required_argument, NULL, OPTION_DLL_SEARCH_PREFIX},
                    330:     {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES},
                    331:     {"enable-auto-import", no_argument, NULL, OPTION_DLL_ENABLE_AUTO_IMPORT},
                    332:     {"disable-auto-import", no_argument, NULL, OPTION_DLL_DISABLE_AUTO_IMPORT},
                    333:     {"enable-extra-pe-debug", no_argument, NULL, OPTION_ENABLE_EXTRA_PE_DEBUG},
                    334:     {"enable-runtime-pseudo-reloc", no_argument, NULL, OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC},
                    335:     {"disable-runtime-pseudo-reloc", no_argument, NULL, OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC},
                    336:     {"enable-runtime-pseudo-reloc-v1", no_argument, NULL, OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V1},
                    337:     {"enable-runtime-pseudo-reloc-v2", no_argument, NULL, OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V2},
                    338: #endif
                    339:     {"large-address-aware", no_argument, NULL, OPTION_LARGE_ADDRESS_AWARE},
1.3       christos  340:     {"disable-large-address-aware", no_argument, NULL, OPTION_DISABLE_LARGE_ADDRESS_AWARE},
1.1       christos  341:     {"enable-long-section-names", no_argument, NULL, OPTION_ENABLE_LONG_SECTION_NAMES},
                    342:     {"disable-long-section-names", no_argument, NULL, OPTION_DISABLE_LONG_SECTION_NAMES},
                    343:     {"dynamicbase",no_argument, NULL, OPTION_DYNAMIC_BASE},
                    344:     {"forceinteg", no_argument, NULL, OPTION_FORCE_INTEGRITY},
                    345:     {"nxcompat", no_argument, NULL, OPTION_NX_COMPAT},
                    346:     {"no-isolation", no_argument, NULL, OPTION_NO_ISOLATION},
                    347:     {"no-seh", no_argument, NULL, OPTION_NO_SEH},
                    348:     {"no-bind", no_argument, NULL, OPTION_NO_BIND},
                    349:     {"wdmdriver", no_argument, NULL, OPTION_WDM_DRIVER},
                    350:     {"tsaware", no_argument, NULL, OPTION_TERMINAL_SERVER_AWARE},
1.3       christos  351:     {"build-id", optional_argument, NULL, OPTION_BUILD_ID},
1.1       christos  352:     {NULL, no_argument, NULL, 0}
                    353:   };
                    354:
                    355:   *longopts
                    356:     = xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long));
                    357:   memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long));
                    358: }
                    359:
                    360: /* PE/WIN32; added routines to get the subsystem type, heap and/or stack
                    361:    parameters which may be input from the command line.  */
                    362:
                    363: typedef struct
                    364: {
                    365:   void *ptr;
                    366:   int size;
                    367:   int value;
                    368:   char *symbol;
                    369:   int inited;
                    370:   /* FALSE for an assembly level symbol and TRUE for a C visible symbol.
                    371:      C visible symbols can be prefixed by underscore dependent to target's
                    372:      settings.  */
                    373:   bfd_boolean is_c_symbol;
                    374: } definfo;
                    375:
                    376: /* Get symbol name dependent to kind and C visible state of
                    377:    underscore.  */
                    378: #define GET_INIT_SYMBOL_NAME(IDX) \
                    379:   (init[(IDX)].symbol \
1.5.2.1 ! martin    380:    + ((!init[(IDX)].is_c_symbol || is_underscoring () != 0) ? 0 : 1))
1.1       christos  381:
                    382: /* Decorates the C visible symbol by underscore, if target requires.  */
                    383: #define U(CSTR) \
                    384:   ((is_underscoring () == 0) ? CSTR : "_" CSTR)
                    385:
1.3       christos  386: #define D(field,symbol,def,usc)  {&pe.field, sizeof (pe.field), def, symbol, 0, usc}
1.1       christos  387:
                    388: static definfo init[] =
                    389: {
                    390:   /* imagebase must be first */
                    391: #define IMAGEBASEOFF 0
                    392:   D(ImageBase,"__image_base__", NT_EXE_IMAGE_BASE, FALSE),
                    393: #define DLLOFF 1
                    394:   {&dll, sizeof(dll), 0, "__dll__", 0, FALSE},
                    395: #define MSIMAGEBASEOFF 2
                    396:   D(ImageBase, "___ImageBase", NT_EXE_IMAGE_BASE, TRUE),
                    397:   D(SectionAlignment,"__section_alignment__", PE_DEF_SECTION_ALIGNMENT, FALSE),
                    398:   D(FileAlignment,"__file_alignment__", PE_DEF_FILE_ALIGNMENT, FALSE),
                    399:   D(MajorOperatingSystemVersion,"__major_os_version__", 4, FALSE),
                    400:   D(MinorOperatingSystemVersion,"__minor_os_version__", 0, FALSE),
                    401:   D(MajorImageVersion,"__major_image_version__", 1, FALSE),
                    402:   D(MinorImageVersion,"__minor_image_version__", 0, FALSE),
                    403: #if defined(TARGET_IS_armpe)  || defined(TARGET_IS_arm_wince_pe)
                    404:   D(MajorSubsystemVersion,"__major_subsystem_version__", 3, FALSE),
                    405: #else
                    406:   D(MajorSubsystemVersion,"__major_subsystem_version__", 4, FALSE),
                    407: #endif
                    408:   D(MinorSubsystemVersion,"__minor_subsystem_version__", 0, FALSE),
                    409:   D(Subsystem,"__subsystem__", ${SUBSYSTEM}, FALSE),
                    410:   D(SizeOfStackReserve,"__size_of_stack_reserve__", 0x200000, FALSE),
                    411:   D(SizeOfStackCommit,"__size_of_stack_commit__", 0x1000, FALSE),
                    412:   D(SizeOfHeapReserve,"__size_of_heap_reserve__", 0x100000, FALSE),
                    413:   D(SizeOfHeapCommit,"__size_of_heap_commit__", 0x1000, FALSE),
                    414:   D(LoaderFlags,"__loader_flags__", 0x0, FALSE),
                    415:   D(DllCharacteristics, "__dll_characteristics__", 0x0, FALSE),
                    416:   { NULL, 0, 0, NULL, 0 , FALSE}
                    417: };
                    418:
                    419:
                    420: static void
                    421: gld_${EMULATION_NAME}_list_options (FILE *file)
                    422: {
                    423:   fprintf (file, _("  --base_file <basefile>             Generate a base file for relocatable DLLs\n"));
                    424:   fprintf (file, _("  --dll                              Set image base to the default for DLLs\n"));
                    425:   fprintf (file, _("  --file-alignment <size>            Set file alignment\n"));
                    426:   fprintf (file, _("  --heap <size>                      Set initial size of the heap\n"));
                    427:   fprintf (file, _("  --image-base <address>             Set start address of the executable\n"));
                    428:   fprintf (file, _("  --major-image-version <number>     Set version number of the executable\n"));
                    429:   fprintf (file, _("  --major-os-version <number>        Set minimum required OS version\n"));
                    430:   fprintf (file, _("  --major-subsystem-version <number> Set minimum required OS subsystem version\n"));
                    431:   fprintf (file, _("  --minor-image-version <number>     Set revision number of the executable\n"));
                    432:   fprintf (file, _("  --minor-os-version <number>        Set minimum required OS revision\n"));
                    433:   fprintf (file, _("  --minor-subsystem-version <number> Set minimum required OS subsystem revision\n"));
                    434:   fprintf (file, _("  --section-alignment <size>         Set section alignment\n"));
                    435:   fprintf (file, _("  --stack <size>                     Set size of the initial stack\n"));
                    436:   fprintf (file, _("  --subsystem <name>[:<version>]     Set required OS subsystem [& version]\n"));
                    437:   fprintf (file, _("  --support-old-code                 Support interworking with old code\n"));
                    438:   fprintf (file, _("  --[no-]leading-underscore          Set explicit symbol underscore prefix mode\n"));
                    439:   fprintf (file, _("  --thumb-entry=<symbol>             Set the entry point to be Thumb <symbol>\n"));
1.3       christos  440:   fprintf (file, _("  --[no-]insert-timestamp            Use a real timestamp rather than zero (default).\n"));
                    441:   fprintf (file, _("                                     This makes binaries non-deterministic\n"));
1.1       christos  442: #ifdef DLL_SUPPORT
                    443:   fprintf (file, _("  --add-stdcall-alias                Export symbols with and without @nn\n"));
                    444:   fprintf (file, _("  --disable-stdcall-fixup            Don't link _sym to _sym@nn\n"));
                    445:   fprintf (file, _("  --enable-stdcall-fixup             Link _sym to _sym@nn without warnings\n"));
                    446:   fprintf (file, _("  --exclude-symbols sym,sym,...      Exclude symbols from automatic export\n"));
                    447:   fprintf (file, _("  --exclude-all-symbols              Exclude all symbols from automatic export\n"));
                    448:   fprintf (file, _("  --exclude-libs lib,lib,...         Exclude libraries from automatic export\n"));
                    449:   fprintf (file, _("  --exclude-modules-for-implib mod,mod,...\n"));
                    450:   fprintf (file, _("                                     Exclude objects, archive members from auto\n"));
                    451:   fprintf (file, _("                                     export, place into import library instead.\n"));
                    452:   fprintf (file, _("  --export-all-symbols               Automatically export all globals to DLL\n"));
                    453:   fprintf (file, _("  --kill-at                          Remove @nn from exported symbols\n"));
                    454:   fprintf (file, _("  --output-def <file>                Generate a .DEF file for the built DLL\n"));
1.3       christos  455:   fprintf (file, _("  --warn-duplicate-exports           Warn about duplicate exports\n"));
1.1       christos  456:   fprintf (file, _("  --compat-implib                    Create backward compatible import libs;\n\
                    457:                                        create __imp_<SYMBOL> as well.\n"));
1.3       christos  458:   fprintf (file, _("  --enable-auto-image-base[=<address>] Automatically choose image base for DLLs\n\
                    459:                                        (optionally starting with address) unless\n\
                    460:                                        specifically set with --image-base\n"));
1.1       christos  461:   fprintf (file, _("  --disable-auto-image-base          Do not auto-choose image base. (default)\n"));
                    462:   fprintf (file, _("  --dll-search-prefix=<string>       When linking dynamically to a dll without\n\
                    463:                                        an importlib, use <string><basename>.dll\n\
                    464:                                        in preference to lib<basename>.dll \n"));
                    465:   fprintf (file, _("  --enable-auto-import               Do sophisticated linking of _sym to\n\
                    466:                                        __imp_sym for DATA references\n"));
                    467:   fprintf (file, _("  --disable-auto-import              Do not auto-import DATA items from DLLs\n"));
                    468:   fprintf (file, _("  --enable-runtime-pseudo-reloc      Work around auto-import limitations by\n\
                    469:                                        adding pseudo-relocations resolved at\n\
                    470:                                        runtime.\n"));
                    471:   fprintf (file, _("  --disable-runtime-pseudo-reloc     Do not add runtime pseudo-relocations for\n\
                    472:                                        auto-imported DATA.\n"));
                    473:   fprintf (file, _("  --enable-extra-pe-debug            Enable verbose debug output when building\n\
                    474:                                        or linking to DLLs (esp. auto-import)\n"));
                    475: #endif
                    476:   fprintf (file, _("  --large-address-aware              Executable supports virtual addresses\n\
                    477:                                        greater than 2 gigabytes\n"));
1.3       christos  478:   fprintf (file, _("  --disable-large-address-aware      Executable does not support virtual\n\
                    479:                                        addresses greater than 2 gigabytes\n"));
1.1       christos  480:   fprintf (file, _("  --enable-long-section-names        Use long COFF section names even in\n\
                    481:                                        executable image files\n"));
                    482:   fprintf (file, _("  --disable-long-section-names       Never use long COFF section names, even\n\
                    483:                                        in object files\n"));
1.5.2.1 ! martin    484:   fprintf (file, _("  --dynamicbase                      Image base address may be relocated using\n\
        !           485:                                        address space layout randomization (ASLR)\n"));
        !           486:   fprintf (file, _("  --forceinteg               Code integrity checks are enforced\n"));
        !           487:   fprintf (file, _("  --nxcompat                 Image is compatible with data execution prevention\n"));
        !           488:   fprintf (file, _("  --no-isolation             Image understands isolation but do not isolate the image\n"));
        !           489:   fprintf (file, _("  --no-seh                   Image does not use SEH. No SE handler may\n\
        !           490:                                        be called in this image\n"));
        !           491:   fprintf (file, _("  --no-bind                  Do not bind this image\n"));
        !           492:   fprintf (file, _("  --wdmdriver                Driver uses the WDM model\n"));
1.1       christos  493:   fprintf (file, _("  --tsaware                  Image is Terminal Server aware\n"));
1.3       christos  494:   fprintf (file, _("  --build-id[=STYLE]         Generate build ID\n"));
1.1       christos  495: }
                    496:
                    497:
                    498: static void
                    499: set_pe_name (char *name, long val)
                    500: {
                    501:   int i;
                    502:   is_underscoring ();
                    503:
                    504:   /* Find the name and set it.  */
                    505:   for (i = 0; init[i].ptr; i++)
                    506:     {
                    507:       if (strcmp (name, GET_INIT_SYMBOL_NAME (i)) == 0)
                    508:        {
                    509:          init[i].value = val;
                    510:          init[i].inited = 1;
                    511:          if (strcmp (name,"__image_base__") == 0)
                    512:            set_pe_name (U ("__ImageBase"), val);
                    513:          return;
                    514:        }
                    515:     }
                    516:   abort ();
                    517: }
                    518:
                    519: static void
                    520: set_entry_point (void)
                    521: {
                    522:   const char *entry;
                    523:   const char *initial_symbol_char;
                    524:   int i;
                    525:
                    526:   static const struct
1.5.2.1 ! martin    527:   {
        !           528:     const int value;
        !           529:     const char *entry;
        !           530:   }
1.1       christos  531:   v[] =
                    532:     {
                    533:       { 1, "NtProcessStartup"  },
                    534:       { 2, "WinMainCRTStartup" },
                    535:       { 3, "mainCRTStartup"    },
                    536:       { 7, "__PosixProcessStartup"},
                    537:       { 9, "WinMainCRTStartup" },
                    538:       {14, "mainCRTStartup"    },
                    539:       { 0, NULL          }
                    540:     };
                    541:
                    542:   /* Entry point name for arbitrary subsystem numbers.  */
                    543:   static const char default_entry[] = "mainCRTStartup";
                    544:
1.3       christos  545:   if (bfd_link_pic (&link_info) || dll)
1.1       christos  546:     {
                    547: #if defined (TARGET_IS_i386pe)
                    548:       entry = "DllMainCRTStartup@12";
                    549: #else
                    550:       entry = "DllMainCRTStartup";
                    551: #endif
                    552:     }
                    553:   else
                    554:     {
                    555:       for (i = 0; v[i].entry; i++)
1.5.2.1 ! martin    556:        if (v[i].value == pe_subsystem)
        !           557:          break;
1.1       christos  558:
                    559:       /* If no match, use the default.  */
                    560:       if (v[i].entry != NULL)
1.5.2.1 ! martin    561:        entry = v[i].entry;
1.1       christos  562:       else
1.5.2.1 ! martin    563:        entry = default_entry;
1.1       christos  564:     }
                    565:
                    566:   initial_symbol_char = (is_underscoring () != 0 ? "_" : "");
                    567:
                    568:   if (*initial_symbol_char != '\0')
                    569:     {
                    570:       char *alc_entry;
                    571:
                    572:       /* lang_default_entry expects its argument to be permanently
                    573:         allocated, so we don't free this string.  */
                    574:       alc_entry = xmalloc (strlen (initial_symbol_char)
                    575:                           + strlen (entry)
                    576:                           + 1);
                    577:       strcpy (alc_entry, initial_symbol_char);
                    578:       strcat (alc_entry, entry);
                    579:       entry = alc_entry;
                    580:     }
                    581:
                    582:   lang_default_entry (entry);
                    583: }
                    584:
                    585: static void
                    586: set_pe_subsystem (void)
                    587: {
                    588:   const char *sver;
                    589:   char *end;
                    590:   int len;
                    591:   int i;
                    592:   unsigned long temp_subsystem;
                    593:   static const struct
                    594:     {
                    595:       const char *name;
                    596:       const int value;
                    597:     }
                    598:   v[] =
                    599:     {
                    600:       { "native",  1},
                    601:       { "windows", 2},
                    602:       { "console", 3},
                    603:       { "posix",   7},
                    604:       { "wince",   9},
                    605:       { "xbox",   14},
                    606:       { NULL, 0 }
                    607:     };
                    608:
                    609:   /* Check for the presence of a version number.  */
                    610:   sver = strchr (optarg, ':');
                    611:   if (sver == NULL)
                    612:     len = strlen (optarg);
                    613:   else
                    614:     {
                    615:       len = sver - optarg;
                    616:       set_pe_name ("__major_subsystem_version__",
                    617:                    strtoul (sver + 1, &end, 0));
                    618:       if (*end == '.')
                    619:        set_pe_name ("__minor_subsystem_version__",
                    620:                      strtoul (end + 1, &end, 0));
                    621:       if (*end != '\0')
                    622:        einfo (_("%P: warning: bad version number in -subsystem option\n"));
                    623:     }
                    624:
                    625:   /* Check for numeric subsystem.  */
                    626:   temp_subsystem = strtoul (optarg, & end, 0);
                    627:   if ((*end == ':' || *end == '\0') && (temp_subsystem < 65536))
                    628:     {
                    629:       /* Search list for a numeric match to use its entry point.  */
                    630:       for (i = 0; v[i].name; i++)
                    631:        if (v[i].value == (int) temp_subsystem)
                    632:          break;
                    633:
                    634:       /* Use this subsystem.  */
                    635:       pe_subsystem = (int) temp_subsystem;
                    636:     }
                    637:   else
                    638:     {
                    639:       /* Search for subsystem by name.  */
                    640:       for (i = 0; v[i].name; i++)
                    641:        if (strncmp (optarg, v[i].name, len) == 0
                    642:            && v[i].name[len] == '\0')
                    643:          break;
                    644:
                    645:       if (v[i].name == NULL)
                    646:        {
1.5.2.1 ! martin    647:          einfo (_("%F%P: invalid subsystem type %s\n"), optarg);
1.1       christos  648:          return;
                    649:        }
                    650:
                    651:       pe_subsystem = v[i].value;
                    652:     }
                    653:
                    654:   set_pe_name ("__subsystem__", pe_subsystem);
                    655:
                    656:   return;
                    657: }
                    658:
                    659:
                    660: static void
                    661: set_pe_value (char *name)
                    662: {
                    663:   char *end;
                    664:
                    665:   set_pe_name (name,  strtoul (optarg, &end, 0));
                    666:
                    667:   if (end == optarg)
1.5.2.1 ! martin    668:     einfo (_("%F%P: invalid hex number for PE parameter '%s'\n"), optarg);
1.1       christos  669:
                    670:   optarg = end;
                    671: }
                    672:
                    673:
                    674: static void
                    675: set_pe_stack_heap (char *resname, char *comname)
                    676: {
                    677:   set_pe_value (resname);
                    678:
                    679:   if (*optarg == ',')
                    680:     {
                    681:       optarg++;
                    682:       set_pe_value (comname);
                    683:     }
                    684:   else if (*optarg)
1.5.2.1 ! martin    685:     einfo (_("%F%P: strange hex info for PE parameter '%s'\n"), optarg);
1.1       christos  686: }
                    687:
1.3       christos  688: #define DEFAULT_BUILD_ID_STYLE "md5"
1.1       christos  689:
                    690: static bfd_boolean
                    691: gld${EMULATION_NAME}_handle_option (int optc)
                    692: {
                    693:   switch (optc)
                    694:     {
                    695:     default:
                    696:       return FALSE;
                    697:
                    698:     case OPTION_BASE_FILE:
                    699:       link_info.base_file = fopen (optarg, FOPEN_WB);
                    700:       if (link_info.base_file == NULL)
                    701:        einfo (_("%F%P: cannot open base file %s\n"), optarg);
                    702:       break;
                    703:
                    704:       /* PE options.  */
                    705:     case OPTION_HEAP:
                    706:       set_pe_stack_heap ("__size_of_heap_reserve__", "__size_of_heap_commit__");
                    707:       break;
                    708:     case OPTION_STACK:
                    709:       set_pe_stack_heap ("__size_of_stack_reserve__", "__size_of_stack_commit__");
                    710:       break;
                    711:     case OPTION_SUBSYSTEM:
                    712:       set_pe_subsystem ();
                    713:       break;
                    714:     case OPTION_MAJOR_OS_VERSION:
                    715:       set_pe_value ("__major_os_version__");
                    716:       break;
                    717:     case OPTION_MINOR_OS_VERSION:
                    718:       set_pe_value ("__minor_os_version__");
                    719:       break;
                    720:     case OPTION_MAJOR_SUBSYSTEM_VERSION:
                    721:       set_pe_value ("__major_subsystem_version__");
                    722:       break;
                    723:     case OPTION_MINOR_SUBSYSTEM_VERSION:
                    724:       set_pe_value ("__minor_subsystem_version__");
                    725:       break;
                    726:     case OPTION_MAJOR_IMAGE_VERSION:
                    727:       set_pe_value ("__major_image_version__");
                    728:       break;
                    729:     case OPTION_MINOR_IMAGE_VERSION:
                    730:       set_pe_value ("__minor_image_version__");
                    731:       break;
                    732:     case OPTION_FILE_ALIGNMENT:
                    733:       set_pe_value ("__file_alignment__");
                    734:       break;
                    735:     case OPTION_SECTION_ALIGNMENT:
                    736:       set_pe_value ("__section_alignment__");
                    737:       break;
                    738:     case OPTION_DLL:
                    739:       set_pe_name ("__dll__", 1);
                    740:       break;
                    741:     case OPTION_IMAGE_BASE:
                    742:       set_pe_value ("__image_base__");
                    743:       break;
                    744:     case OPTION_SUPPORT_OLD_CODE:
                    745:       support_old_code = 1;
                    746:       break;
                    747:     case OPTION_THUMB_ENTRY:
                    748:       thumb_entry_symbol = optarg;
                    749:       break;
                    750:     case OPTION_USE_NUL_PREFIXED_IMPORT_TABLES:
                    751:       pe_use_nul_prefixed_import_tables = TRUE;
                    752:       break;
                    753:     case OPTION_NO_LEADING_UNDERSCORE:
                    754:       pe_leading_underscore = 0;
                    755:       break;
                    756:     case OPTION_LEADING_UNDERSCORE:
                    757:       pe_leading_underscore = 1;
                    758:       break;
1.3       christos  759:     case OPTION_INSERT_TIMESTAMP:
                    760:       insert_timestamp = TRUE;
                    761:       break;
                    762:     case OPTION_NO_INSERT_TIMESTAMP:
                    763:       insert_timestamp = FALSE;
                    764:       break;
1.1       christos  765: #ifdef DLL_SUPPORT
                    766:     case OPTION_OUT_DEF:
                    767:       pe_out_def_filename = xstrdup (optarg);
                    768:       break;
                    769:     case OPTION_EXPORT_ALL:
                    770:       pe_dll_export_everything = 1;
                    771:       break;
                    772:     case OPTION_EXCLUDE_SYMBOLS:
                    773:       pe_dll_add_excludes (optarg, EXCLUDESYMS);
                    774:       break;
                    775:     case OPTION_EXCLUDE_ALL_SYMBOLS:
                    776:       pe_dll_exclude_all_symbols = 1;
                    777:       break;
                    778:     case OPTION_EXCLUDE_LIBS:
                    779:       pe_dll_add_excludes (optarg, EXCLUDELIBS);
                    780:       break;
                    781:     case OPTION_EXCLUDE_MODULES_FOR_IMPLIB:
                    782:       pe_dll_add_excludes (optarg, EXCLUDEFORIMPLIB);
                    783:       break;
                    784:     case OPTION_KILL_ATS:
                    785:       pe_dll_kill_ats = 1;
                    786:       break;
                    787:     case OPTION_STDCALL_ALIASES:
                    788:       pe_dll_stdcall_aliases = 1;
                    789:       break;
                    790:     case OPTION_ENABLE_STDCALL_FIXUP:
                    791:       pe_enable_stdcall_fixup = 1;
                    792:       break;
                    793:     case OPTION_DISABLE_STDCALL_FIXUP:
                    794:       pe_enable_stdcall_fixup = 0;
                    795:       break;
                    796:     case OPTION_WARN_DUPLICATE_EXPORTS:
                    797:       pe_dll_warn_dup_exports = 1;
                    798:       break;
                    799:     case OPTION_IMP_COMPAT:
                    800:       pe_dll_compat_implib = 1;
                    801:       break;
                    802:     case OPTION_ENABLE_AUTO_IMAGE_BASE:
                    803:       pe_enable_auto_image_base = 1;
1.3       christos  804:       if (optarg && *optarg)
                    805:        {
                    806:          char *end;
                    807:          pe_auto_image_base = strtoul (optarg, &end, 0);
                    808:          /* XXX should check that we actually parsed something */
                    809:        }
1.1       christos  810:       break;
                    811:     case OPTION_DISABLE_AUTO_IMAGE_BASE:
                    812:       pe_enable_auto_image_base = 0;
                    813:       break;
                    814:     case OPTION_DLL_SEARCH_PREFIX:
                    815:       pe_dll_search_prefix = xstrdup (optarg);
                    816:       break;
                    817:     case OPTION_NO_DEFAULT_EXCLUDES:
                    818:       pe_dll_do_default_excludes = 0;
                    819:       break;
                    820:     case OPTION_DLL_ENABLE_AUTO_IMPORT:
                    821:       link_info.pei386_auto_import = 1;
                    822:       break;
                    823:     case OPTION_DLL_DISABLE_AUTO_IMPORT:
                    824:       link_info.pei386_auto_import = 0;
                    825:       break;
                    826:     case OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC:
                    827:       link_info.pei386_runtime_pseudo_reloc =
                    828:        DEFAULT_PSEUDO_RELOC_VERSION;
                    829:       break;
                    830:     case OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V1:
                    831:       link_info.pei386_runtime_pseudo_reloc = 1;
                    832:       break;
                    833:     case OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V2:
                    834:       link_info.pei386_runtime_pseudo_reloc = 2;
                    835:       break;
                    836:     case OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC:
                    837:       link_info.pei386_runtime_pseudo_reloc = 0;
                    838:       break;
                    839:     case OPTION_ENABLE_EXTRA_PE_DEBUG:
                    840:       pe_dll_extra_pe_debug = 1;
                    841:       break;
                    842: #endif
                    843:     case OPTION_LARGE_ADDRESS_AWARE:
                    844:       real_flags |= IMAGE_FILE_LARGE_ADDRESS_AWARE;
                    845:       break;
1.3       christos  846:     case OPTION_DISABLE_LARGE_ADDRESS_AWARE:
                    847:       real_flags &= ~ IMAGE_FILE_LARGE_ADDRESS_AWARE;
                    848:       break;
1.1       christos  849:     case OPTION_ENABLE_LONG_SECTION_NAMES:
                    850:       pe_use_coff_long_section_names = 1;
                    851:       break;
                    852:     case OPTION_DISABLE_LONG_SECTION_NAMES:
                    853:       pe_use_coff_long_section_names = 0;
                    854:       break;
                    855: /*  Get DLLCharacteristics bits  */
                    856:     case OPTION_DYNAMIC_BASE:
                    857:       pe_dll_characteristics |= IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE;
                    858:       break;
                    859:     case OPTION_FORCE_INTEGRITY:
                    860:       pe_dll_characteristics |= IMAGE_DLL_CHARACTERISTICS_FORCE_INTEGRITY;
                    861:       break;
                    862:     case OPTION_NX_COMPAT:
                    863:       pe_dll_characteristics |= IMAGE_DLL_CHARACTERISTICS_NX_COMPAT;
                    864:       break;
                    865:     case OPTION_NO_ISOLATION:
                    866:       pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_NO_ISOLATION;
                    867:       break;
                    868:     case OPTION_NO_SEH:
                    869:       pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_NO_SEH;
                    870:       break;
                    871:     case OPTION_NO_BIND:
                    872:       pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_NO_BIND;
                    873:       break;
                    874:     case OPTION_WDM_DRIVER:
                    875:       pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_WDM_DRIVER;
                    876:       break;
                    877:     case OPTION_TERMINAL_SERVER_AWARE:
                    878:       pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE;
                    879:       break;
1.3       christos  880:     case OPTION_BUILD_ID:
                    881:       if (emit_build_id != NULL)
                    882:        {
                    883:          free ((char *) emit_build_id);
                    884:          emit_build_id = NULL;
                    885:        }
                    886:       if (optarg == NULL)
                    887:        optarg = DEFAULT_BUILD_ID_STYLE;
                    888:       if (strcmp (optarg, "none"))
                    889:        emit_build_id = xstrdup (optarg);
                    890:       break;
1.1       christos  891:     }
                    892:
                    893:   /*  Set DLLCharacteristics bits  */
                    894:   set_pe_name ("__dll_characteristics__", pe_dll_characteristics);
                    895:
                    896:   return TRUE;
                    897: }
                    898: 
                    899:
                    900: #ifdef DLL_SUPPORT
                    901: static unsigned long
                    902: strhash (const char *str)
                    903: {
                    904:   const unsigned char *s;
                    905:   unsigned long hash;
                    906:   unsigned int c;
                    907:   unsigned int len;
                    908:
                    909:   hash = 0;
                    910:   len = 0;
                    911:   s = (const unsigned char *) str;
                    912:   while ((c = *s++) != '\0')
                    913:     {
                    914:       hash += c + (c << 17);
                    915:       hash ^= hash >> 2;
                    916:       ++len;
                    917:     }
                    918:   hash += len + (len << 17);
                    919:   hash ^= hash >> 2;
                    920:
                    921:   return hash;
                    922: }
                    923:
                    924: /* Use the output file to create a image base for relocatable DLLs.  */
                    925:
                    926: static unsigned long
                    927: compute_dll_image_base (const char *ofile)
                    928: {
                    929:   unsigned long hash = strhash (ofile);
1.3       christos  930:   return pe_auto_image_base + ((hash << 16) & 0x0FFC0000);
1.1       christos  931: }
                    932: #endif
                    933:
                    934: /* Assign values to the special symbols before the linker script is
                    935:    read.  */
                    936:
                    937: static void
                    938: gld_${EMULATION_NAME}_set_symbols (void)
                    939: {
                    940:   /* Run through and invent symbols for all the
                    941:      names and insert the defaults.  */
                    942:   int j;
                    943:
                    944:   is_underscoring ();
                    945:
                    946:   if (!init[IMAGEBASEOFF].inited)
                    947:     {
1.3       christos  948:       if (bfd_link_relocatable (&link_info))
1.1       christos  949:        init[IMAGEBASEOFF].value = 0;
1.3       christos  950:       else if (init[DLLOFF].value || bfd_link_dll (&link_info))
1.1       christos  951:        {
                    952: #ifdef DLL_SUPPORT
                    953:          init[IMAGEBASEOFF].value = (pe_enable_auto_image_base
                    954:                                      ? compute_dll_image_base (output_filename)
                    955:                                      : NT_DLL_IMAGE_BASE);
                    956: #else
                    957:          init[IMAGEBASEOFF].value = NT_DLL_IMAGE_BASE;
                    958: #endif
                    959:        }
                    960:       else
                    961:        init[IMAGEBASEOFF].value = NT_EXE_IMAGE_BASE;
                    962:       init[MSIMAGEBASEOFF].value = init[IMAGEBASEOFF].value;
                    963:     }
                    964:
                    965:   /* Don't do any symbol assignments if this is a relocatable link.  */
1.3       christos  966:   if (bfd_link_relocatable (&link_info))
1.1       christos  967:     return;
                    968:
                    969:   /* Glue the assignments into the abs section.  */
                    970:   push_stat_ptr (&abs_output_section->children);
                    971:
                    972:   for (j = 0; init[j].ptr; j++)
                    973:     {
                    974:       long val = init[j].value;
                    975:       lang_assignment_statement_type *rv;
                    976:
                    977:       rv = lang_add_assignment (exp_assign (GET_INIT_SYMBOL_NAME (j),
                    978:                                            exp_intop (val), FALSE));
                    979:       if (init[j].size == sizeof (short))
                    980:        *(short *) init[j].ptr = val;
                    981:       else if (init[j].size == sizeof (int))
                    982:        *(int *) init[j].ptr = val;
                    983:       else if (init[j].size == sizeof (long))
                    984:        *(long *) init[j].ptr = val;
                    985:       /* This might be a long long or other special type.  */
                    986:       else if (init[j].size == sizeof (bfd_vma))
                    987:        *(bfd_vma *) init[j].ptr = val;
                    988:       else     abort ();
                    989:       if (j == IMAGEBASEOFF)
                    990:        image_base_statement = rv;
                    991:     }
                    992:   /* Restore the pointer.  */
                    993:   pop_stat_ptr ();
                    994:
                    995:   if (pe.FileAlignment > pe.SectionAlignment)
                    996:     {
1.5.2.1 ! martin    997:       einfo (_("%P: warning, file alignment > section alignment\n"));
1.1       christos  998:     }
                    999: }
                   1000:
                   1001: /* This is called after the linker script and the command line options
                   1002:    have been read.  */
                   1003:
                   1004: static void
                   1005: gld_${EMULATION_NAME}_after_parse (void)
                   1006: {
                   1007:   /* PR ld/6744:  Warn the user if they have used an ELF-only
                   1008:      option hoping it will work on PE.  */
                   1009:   if (link_info.export_dynamic)
                   1010:     einfo (_("%P: warning: --export-dynamic is not supported for PE "
                   1011:       "targets, did you mean --export-all-symbols?\n"));
                   1012:
                   1013:   set_entry_point ();
                   1014:
                   1015:   after_parse_default ();
                   1016: }
                   1017:
                   1018: #ifdef DLL_SUPPORT
                   1019: static struct bfd_link_hash_entry *pe_undef_found_sym;
                   1020:
                   1021: static bfd_boolean
                   1022: pe_undef_cdecl_match (struct bfd_link_hash_entry *h, void *inf)
                   1023: {
                   1024:   int sl;
                   1025:   char *string = inf;
                   1026:   const char *hs = h->root.string;
                   1027:
                   1028:   sl = strlen (string);
                   1029:   if (h->type == bfd_link_hash_defined
                   1030:       && ((*hs == '@' && *string == '_'
                   1031:                   && strncmp (hs + 1, string + 1, sl - 1) == 0)
                   1032:                  || strncmp (hs, string, sl) == 0)
                   1033:       && h->root.string[sl] == '@')
                   1034:     {
                   1035:       pe_undef_found_sym = h;
                   1036:       return FALSE;
                   1037:     }
                   1038:   return TRUE;
                   1039: }
                   1040:
1.5       christos 1041: /* Change UNDEF to a defined symbol, taking data from SYM.  */
                   1042:
                   1043: static void
                   1044: change_undef (struct bfd_link_hash_entry * undef,
                   1045:              struct bfd_link_hash_entry * sym)
                   1046: {
                   1047:   static bfd_boolean  gave_warning_message = FALSE;
                   1048:
                   1049:   undef->type = bfd_link_hash_defined;
                   1050:   undef->u.def.value = sym->u.def.value;
                   1051:   undef->u.def.section = sym->u.def.section;
                   1052:
                   1053:   if (pe_enable_stdcall_fixup == -1)
                   1054:     {
1.5.2.1 ! martin   1055:       einfo (_("%P: warning: resolving %s by linking to %s\n"),
1.5       christos 1056:             undef->root.string, sym->root.string);
                   1057:
                   1058:       if (! gave_warning_message)
                   1059:        {
                   1060:          einfo (_("Use --enable-stdcall-fixup to disable these warnings\n"));
                   1061:          einfo (_("Use --disable-stdcall-fixup to disable these fixups\n"));
                   1062:          gave_warning_message = TRUE;
                   1063:        }
                   1064:     }
                   1065:
                   1066:   /* PR 19803: Make sure that the linked symbol is not garbage collected.  */
                   1067:   lang_add_gc_name (sym->root.string);
                   1068: }
                   1069:
1.1       christos 1070: static void
                   1071: pe_fixup_stdcalls (void)
                   1072: {
                   1073:   struct bfd_link_hash_entry *undef, *sym;
                   1074:
                   1075:   if (pe_dll_extra_pe_debug)
                   1076:     printf ("%s\n", __FUNCTION__);
                   1077:
                   1078:   for (undef = link_info.hash->undefs; undef; undef=undef->u.undef.next)
                   1079:     if (undef->type == bfd_link_hash_undefined)
                   1080:       {
1.5       christos 1081:        const char * name = undef->root.string;
                   1082:        char * at;
                   1083:        int lead_at = (*name == '@');
                   1084:
1.1       christos 1085:        if (lead_at)
1.5       christos 1086:          at = strchr (name + 1, '@');
                   1087:        else
                   1088:          at = strchr (name, '@');
1.1       christos 1089:
                   1090:        if (at || lead_at)
                   1091:          {
                   1092:            /* The symbol is a stdcall symbol, so let's look for a
                   1093:               cdecl symbol with the same name and resolve to that.  */
1.5       christos 1094:            char *cname = xstrdup (name);
1.1       christos 1095:
                   1096:            if (lead_at)
                   1097:              *cname = '_';
1.5.2.1 ! martin   1098:            if (at)
1.5       christos 1099:              * strchr (cname, '@') = 0;
                   1100:            sym = bfd_link_hash_lookup (link_info.hash, cname, FALSE, FALSE, TRUE);
1.1       christos 1101:
                   1102:            if (sym && sym->type == bfd_link_hash_defined)
1.5       christos 1103:              change_undef (undef, sym);
1.1       christos 1104:          }
                   1105:        else
                   1106:          {
                   1107:            /* The symbol is a cdecl symbol, so we look for stdcall
                   1108:               symbols - which means scanning the whole symbol table.  */
1.5       christos 1109:            pe_undef_found_sym = NULL;
1.1       christos 1110:            bfd_link_hash_traverse (link_info.hash, pe_undef_cdecl_match,
1.5       christos 1111:                                    (char *) name);
                   1112:            if (pe_undef_found_sym)
                   1113:              change_undef (undef, pe_undef_found_sym);
1.1       christos 1114:          }
                   1115:       }
                   1116: }
                   1117:
1.5.2.1 ! martin   1118: static void
        !          1119: make_import_fixup (arelent *rel, asection *s, char *name, const char *symname)
1.1       christos 1120: {
                   1121:   struct bfd_symbol *sym = *rel->sym_ptr_ptr;
                   1122:   char addend[4];
1.5.2.1 ! martin   1123:   bfd_vma _addend;
1.1       christos 1124:
                   1125:   if (pe_dll_extra_pe_debug)
                   1126:     printf ("arelent: %s@%#lx: add=%li\n", sym->name,
                   1127:            (unsigned long) rel->address, (long) rel->addend);
                   1128:
                   1129:   if (! bfd_get_section_contents (s->owner, s, addend, rel->address, sizeof (addend)))
1.5.2.1 ! martin   1130:     einfo (_("%P: %C: cannot get section contents - auto-import exception\n"),
1.1       christos 1131:           s->owner, s, rel->address);
                   1132:
1.5.2.1 ! martin   1133:   _addend = bfd_get_32 (s->owner, addend);
        !          1134:   pe_create_import_fixup (rel, s, _addend, name, symname);
1.1       christos 1135: }
                   1136:
                   1137: static bfd_boolean
                   1138: pr_sym (struct bfd_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
                   1139: {
                   1140:   printf ("+%s\n", h->string);
                   1141:
                   1142:   return TRUE;
                   1143: }
                   1144: #endif /* DLL_SUPPORT */
                   1145:
1.3       christos 1146: static void
1.1       christos 1147: debug_section_p (bfd *abfd ATTRIBUTE_UNUSED, asection *sect, void *obj)
                   1148: {
                   1149:   int *found = (int *) obj;
                   1150:   if (strncmp (".debug_", sect->name, sizeof (".debug_") - 1) == 0)
                   1151:     *found = 1;
                   1152: }
                   1153:
1.3       christos 1154: static bfd_boolean
                   1155: pecoff_checksum_contents (bfd *abfd,
                   1156:                          void (*process) (const void *, size_t, void *),
                   1157:                          void *arg)
                   1158: {
                   1159:   file_ptr filepos = (file_ptr) 0;
                   1160:
                   1161:   while (1)
                   1162:     {
                   1163:       unsigned char b;
                   1164:       int status;
                   1165:
                   1166:       if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
                   1167:        return 0;
                   1168:
                   1169:       status = bfd_bread (&b, (bfd_size_type) 1, abfd);
                   1170:       if (status < 1)
1.5.2.1 ! martin   1171:        {
        !          1172:          break;
        !          1173:        }
1.3       christos 1174:
                   1175:       (*process) (&b, 1, arg);
                   1176:       filepos += 1;
                   1177:     }
                   1178:
                   1179:   return TRUE;
                   1180: }
                   1181:
                   1182: static bfd_boolean
                   1183: write_build_id (bfd *abfd)
                   1184: {
                   1185:   struct pe_tdata *t = pe_data (abfd);
                   1186:   asection *asec;
                   1187:   struct bfd_link_order *link_order = NULL;
                   1188:   unsigned char *contents;
                   1189:   bfd_size_type size;
                   1190:   bfd_size_type build_id_size;
                   1191:   unsigned char *build_id;
                   1192:
                   1193:   /* Find the section the .buildid output section has been merged info.  */
                   1194:   for (asec = abfd->sections; asec != NULL; asec = asec->next)
                   1195:     {
                   1196:       struct bfd_link_order *l = NULL;
                   1197:       for (l = asec->map_head.link_order; l != NULL; l = l->next)
1.5.2.1 ! martin   1198:        {
        !          1199:          if (l->type == bfd_indirect_link_order)
        !          1200:            {
        !          1201:              if (l->u.indirect.section == t->build_id.sec)
        !          1202:                {
        !          1203:                  link_order = l;
        !          1204:                  break;
        !          1205:                }
        !          1206:            }
        !          1207:        }
1.3       christos 1208:
                   1209:       if (link_order)
1.5.2.1 ! martin   1210:        break;
1.3       christos 1211:     }
                   1212:
                   1213:   if (!link_order)
                   1214:     {
                   1215:       einfo (_("%P: warning: .buildid section discarded,"
1.5.2.1 ! martin   1216:               " --build-id ignored\n"));
1.3       christos 1217:       return TRUE;
                   1218:     }
                   1219:
                   1220:   if (t->build_id.sec->contents == NULL)
                   1221:     t->build_id.sec->contents = (unsigned char *) xmalloc (t->build_id.sec->size);
                   1222:   contents = t->build_id.sec->contents;
                   1223:   size = t->build_id.sec->size;
                   1224:
                   1225:   build_id_size = compute_build_id_size (t->build_id.style);
                   1226:   build_id = xmalloc (build_id_size);
                   1227:   generate_build_id (abfd, t->build_id.style, pecoff_checksum_contents, build_id, build_id_size);
                   1228:
                   1229:   bfd_vma ib = pe_data (link_info.output_bfd)->pe_opthdr.ImageBase;
                   1230:
                   1231:   /* Construct a debug directory entry which points to an immediately following CodeView record.  */
                   1232:   struct internal_IMAGE_DEBUG_DIRECTORY idd;
                   1233:   idd.Characteristics = 0;
                   1234:   idd.TimeDateStamp = 0;
                   1235:   idd.MajorVersion = 0;
                   1236:   idd.MinorVersion = 0;
                   1237:   idd.Type = PE_IMAGE_DEBUG_TYPE_CODEVIEW;
                   1238:   idd.SizeOfData = sizeof (CV_INFO_PDB70) + 1;
                   1239:   idd.AddressOfRawData = asec->vma - ib + link_order->offset
                   1240:     + sizeof (struct external_IMAGE_DEBUG_DIRECTORY);
                   1241:   idd.PointerToRawData = asec->filepos + link_order->offset
                   1242:     + sizeof (struct external_IMAGE_DEBUG_DIRECTORY);
                   1243:
                   1244:   struct external_IMAGE_DEBUG_DIRECTORY *ext = (struct external_IMAGE_DEBUG_DIRECTORY *)contents;
                   1245:   _bfd_XXi_swap_debugdir_out (abfd, &idd, ext);
                   1246:
                   1247:   /* Write the debug directory entry.  */
                   1248:   if (bfd_seek (abfd, asec->filepos + link_order->offset, SEEK_SET) != 0)
                   1249:     return 0;
                   1250:
                   1251:   if (bfd_bwrite (contents, size, abfd) != size)
                   1252:     return 0;
                   1253:
                   1254:   /* Construct the CodeView record.  */
                   1255:   CODEVIEW_INFO cvinfo;
                   1256:   cvinfo.CVSignature = CVINFO_PDB70_CVSIGNATURE;
                   1257:   cvinfo.Age = 1;
                   1258:
                   1259:   /* Zero pad or truncate the generated build_id to fit in the CodeView record.  */
                   1260:   memset (&(cvinfo.Signature), 0, CV_INFO_SIGNATURE_LENGTH);
                   1261:   memcpy (&(cvinfo.Signature), build_id, (build_id_size > CV_INFO_SIGNATURE_LENGTH)
                   1262:          ? CV_INFO_SIGNATURE_LENGTH :  build_id_size);
                   1263:
                   1264:   free (build_id);
                   1265:
                   1266:   /* Write the codeview record.  */
                   1267:   if (_bfd_XXi_write_codeview_record (abfd, idd.PointerToRawData, &cvinfo) == 0)
                   1268:     return 0;
                   1269:
                   1270:   /* Record the location of the debug directory in the data directory.  */
                   1271:   pe_data (link_info.output_bfd)->pe_opthdr.DataDirectory[PE_DEBUG_DATA].VirtualAddress
                   1272:     = asec->vma  - ib + link_order->offset;
                   1273:   pe_data (link_info.output_bfd)->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size
                   1274:     = sizeof (struct external_IMAGE_DEBUG_DIRECTORY);
                   1275:
                   1276:   return TRUE;
                   1277: }
                   1278:
                   1279: /* Make .buildid section, and set up coff_tdata->build_id. */
                   1280: static bfd_boolean
                   1281: setup_build_id (bfd *ibfd)
                   1282: {
                   1283:   asection *s;
                   1284:   flagword flags;
                   1285:
                   1286:   if (!validate_build_id_style (emit_build_id))
                   1287:     {
1.5.2.1 ! martin   1288:       einfo (_("%P: warning: unrecognized --build-id style ignored\n"));
1.3       christos 1289:       return FALSE;
                   1290:     }
                   1291:
                   1292:   flags = (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_IN_MEMORY
                   1293:           | SEC_LINKER_CREATED | SEC_READONLY | SEC_DATA);
                   1294:   s = bfd_make_section_anyway_with_flags (ibfd, ".buildid", flags);
                   1295:   if (s != NULL)
                   1296:     {
                   1297:       struct pe_tdata *t = pe_data (link_info.output_bfd);
                   1298:       t->build_id.after_write_object_contents = &write_build_id;
                   1299:       t->build_id.style = emit_build_id;
                   1300:       t->build_id.sec = s;
                   1301:
                   1302:       /* Section is a fixed size:
                   1303:         One IMAGE_DEBUG_DIRECTORY entry, of type IMAGE_DEBUG_TYPE_CODEVIEW,
                   1304:         pointing at a CV_INFO_PDB70 record containing the build-id, with a
                   1305:         null byte for PdbFileName.  */
                   1306:       s->size = sizeof (struct external_IMAGE_DEBUG_DIRECTORY)
                   1307:        + sizeof (CV_INFO_PDB70) + 1;
                   1308:
                   1309:       return TRUE;
                   1310:     }
                   1311:
1.5.2.1 ! martin   1312:   einfo (_("%P: warning: cannot create .buildid section,"
        !          1313:           " --build-id ignored\n"));
1.3       christos 1314:   return FALSE;
                   1315: }
                   1316:
1.1       christos 1317: static void
                   1318: gld_${EMULATION_NAME}_after_open (void)
                   1319: {
                   1320:   after_open_default ();
                   1321:
                   1322: #ifdef DLL_SUPPORT
                   1323:   if (pe_dll_extra_pe_debug)
                   1324:     {
                   1325:       bfd *a;
                   1326:       struct bfd_link_hash_entry *sym;
                   1327:
                   1328:       printf ("%s()\n", __FUNCTION__);
                   1329:
                   1330:       for (sym = link_info.hash->undefs; sym; sym=sym->u.undef.next)
                   1331:        printf ("-%s\n", sym->root.string);
                   1332:       bfd_hash_traverse (&link_info.hash->table, pr_sym, NULL);
                   1333:
1.3       christos 1334:       for (a = link_info.input_bfds; a; a = a->link.next)
1.1       christos 1335:        printf ("*%s\n",a->filename);
                   1336:     }
                   1337: #endif
                   1338:
1.3       christos 1339:   if (emit_build_id != NULL)
                   1340:     {
                   1341:       bfd *abfd;
                   1342:
                   1343:       /* Find a COFF input.  */
                   1344:       for (abfd = link_info.input_bfds;
                   1345:           abfd != (bfd *) NULL; abfd = abfd->link.next)
                   1346:        if (bfd_get_flavour (abfd) == bfd_target_coff_flavour)
                   1347:          break;
                   1348:
                   1349:       /* If there are no COFF input files do not try to
                   1350:         add a build-id section.  */
                   1351:       if (abfd == NULL
                   1352:          || !setup_build_id (abfd))
                   1353:        {
                   1354:          free ((char *) emit_build_id);
                   1355:          emit_build_id = NULL;
                   1356:        }
                   1357:     }
                   1358:
1.1       christos 1359:   /* Pass the wacky PE command line options into the output bfd.
                   1360:      FIXME: This should be done via a function, rather than by
                   1361:      including an internal BFD header.  */
                   1362:
                   1363:   if (coff_data (link_info.output_bfd) == NULL
                   1364:       || coff_data (link_info.output_bfd)->pe == 0)
1.5.2.1 ! martin   1365:     einfo (_("%F%P: cannot perform PE operations on non PE output file '%pB'\n"),
1.1       christos 1366:           link_info.output_bfd);
                   1367:
                   1368:   pe_data (link_info.output_bfd)->pe_opthdr = pe;
                   1369:   pe_data (link_info.output_bfd)->dll = init[DLLOFF].value;
                   1370:   pe_data (link_info.output_bfd)->real_flags |= real_flags;
1.3       christos 1371:   pe_data (link_info.output_bfd)->insert_timestamp = insert_timestamp;
1.1       christos 1372:
                   1373:   /* At this point we must decide whether to use long section names
                   1374:      in the output or not.  If the user hasn't explicitly specified
                   1375:      on the command line, we leave it to the default for the format
                   1376:      (object files yes, image files no), except if there is debug
                   1377:      information present; GDB relies on the long section names to
                   1378:      find it, so enable it in that case.  */
                   1379:   if (pe_use_coff_long_section_names < 0 && link_info.strip == strip_none)
                   1380:     {
1.3       christos 1381:       if (bfd_link_relocatable (&link_info))
                   1382:        pe_use_coff_long_section_names = 1;
                   1383:       else
1.1       christos 1384:        {
1.3       christos 1385:          /* Iterate over all sections of all input BFDs, checking
                   1386:             for any that begin 'debug_' and are long names.  */
                   1387:          LANG_FOR_EACH_INPUT_STATEMENT (is)
                   1388:          {
                   1389:            int found_debug = 0;
                   1390:
                   1391:            bfd_map_over_sections (is->the_bfd, debug_section_p, &found_debug);
                   1392:            if (found_debug)
                   1393:              {
                   1394:                pe_use_coff_long_section_names = 1;
                   1395:                break;
                   1396:              }
                   1397:          }
1.1       christos 1398:        }
                   1399:     }
                   1400:
                   1401:   pe_output_file_set_long_section_names (link_info.output_bfd);
                   1402:
                   1403: #ifdef DLL_SUPPORT
                   1404:   pe_process_import_defs (link_info.output_bfd, &link_info);
                   1405:
1.5.2.1 ! martin   1406:   if (link_info.pei386_auto_import) /* -1=warn or 1=enable */
        !          1407:     pe_find_data_imports (U ("_head_"), make_import_fixup);
1.1       christos 1408:
1.5.2.1 ! martin   1409:   /* The implementation of the feature is rather dumb and would cause the
        !          1410:      compilation time to go through the roof if there are many undefined
        !          1411:      symbols in the link, so it needs to be run after auto-import.  */
        !          1412:   if (pe_enable_stdcall_fixup) /* -1=warn or 1=enable */
1.1       christos 1413:     pe_fixup_stdcalls ();
                   1414:
                   1415: #if defined (TARGET_IS_i386pe) \
                   1416:     || defined (TARGET_IS_armpe) \
                   1417:     || defined (TARGET_IS_arm_wince_pe)
1.3       christos 1418:   if (!bfd_link_relocatable (&link_info))
1.1       christos 1419:     pe_dll_build_sections (link_info.output_bfd, &link_info);
                   1420: #else
1.3       christos 1421:   if (bfd_link_pic (&link_info))
1.1       christos 1422:     pe_dll_build_sections (link_info.output_bfd, &link_info);
                   1423:   else
                   1424:     pe_exe_build_sections (link_info.output_bfd, &link_info);
                   1425: #endif
                   1426: #endif /* DLL_SUPPORT */
                   1427:
1.5.2.1 ! martin   1428: #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_wince_pe)
1.1       christos 1429:   if (strstr (bfd_get_target (link_info.output_bfd), "arm") == NULL)
                   1430:     {
                   1431:       /* The arm backend needs special fields in the output hash structure.
                   1432:         These will only be created if the output format is an arm format,
                   1433:         hence we do not support linking and changing output formats at the
                   1434:         same time.  Use a link followed by objcopy to change output formats.  */
1.5.2.1 ! martin   1435:       einfo (_("%F%P: error: cannot change output format "
        !          1436:               "whilst linking %s binaries\n"), "ARM");
1.1       christos 1437:       return;
                   1438:     }
                   1439:   {
                   1440:     /* Find a BFD that can hold the interworking stubs.  */
                   1441:     LANG_FOR_EACH_INPUT_STATEMENT (is)
                   1442:       {
                   1443:        if (bfd_arm_get_bfd_for_interworking (is->the_bfd, & link_info))
                   1444:          break;
                   1445:       }
                   1446:   }
                   1447: #endif
                   1448:
                   1449:   {
                   1450:     /* This next chunk of code tries to detect the case where you have
                   1451:        two import libraries for the same DLL (specifically,
                   1452:        symbolically linking libm.a and libc.a in cygwin to
                   1453:        libcygwin.a).  In those cases, it's possible for function
                   1454:        thunks from the second implib to be used but without the
                   1455:        head/tail objects, causing an improper import table.  We detect
                   1456:        those cases and rename the "other" import libraries to match
                   1457:        the one the head/tail come from, so that the linker will sort
                   1458:        things nicely and produce a valid import table.  */
                   1459:
                   1460:     LANG_FOR_EACH_INPUT_STATEMENT (is)
                   1461:       {
                   1462:        if (is->the_bfd->my_archive)
                   1463:          {
                   1464:            int idata2 = 0, reloc_count=0, is_imp = 0;
                   1465:            asection *sec;
                   1466:
                   1467:            /* See if this is an import library thunk.  */
                   1468:            for (sec = is->the_bfd->sections; sec; sec = sec->next)
                   1469:              {
                   1470:                if (strcmp (sec->name, ".idata\$2") == 0)
                   1471:                  idata2 = 1;
                   1472:                if (CONST_STRNEQ (sec->name, ".idata\$"))
                   1473:                  is_imp = 1;
                   1474:                reloc_count += sec->reloc_count;
                   1475:              }
                   1476:
                   1477:            if (is_imp && !idata2 && reloc_count)
                   1478:              {
                   1479:                /* It is, look for the reference to head and see if it's
                   1480:                   from our own library.  */
                   1481:                for (sec = is->the_bfd->sections; sec; sec = sec->next)
                   1482:                  {
                   1483:                    int i;
                   1484:                    long relsize;
                   1485:                    asymbol **symbols;
                   1486:                    arelent **relocs;
                   1487:                    int nrelocs;
                   1488:
                   1489:                    relsize = bfd_get_reloc_upper_bound (is->the_bfd, sec);
                   1490:                    if (relsize < 1)
                   1491:                      break;
                   1492:
                   1493:                    if (!bfd_generic_link_read_symbols (is->the_bfd))
                   1494:                      {
1.5.2.1 ! martin   1495:                        einfo (_("%F%P: %pB: could not read symbols: %E\n"),
1.1       christos 1496:                               is->the_bfd);
                   1497:                        return;
                   1498:                      }
                   1499:                    symbols = bfd_get_outsymbols (is->the_bfd);
                   1500:
                   1501:                    relocs = xmalloc ((size_t) relsize);
                   1502:                    nrelocs = bfd_canonicalize_reloc (is->the_bfd, sec,
                   1503:                                                      relocs, symbols);
                   1504:                    if (nrelocs < 0)
                   1505:                      {
                   1506:                        free (relocs);
1.5.2.1 ! martin   1507:                        einfo (_("%X%P: unable to process relocs: %E\n"));
1.1       christos 1508:                        return;
                   1509:                      }
                   1510:
                   1511:                    for (i = 0; i < nrelocs; i++)
                   1512:                      {
                   1513:                        struct bfd_symbol *s;
                   1514:                        struct bfd_link_hash_entry * blhe;
                   1515:                        char *other_bfd_filename;
                   1516:                        char *n;
                   1517:
                   1518:                        s = (relocs[i]->sym_ptr_ptr)[0];
                   1519:
                   1520:                        if (s->flags & BSF_LOCAL)
                   1521:                          continue;
                   1522:
                   1523:                        /* Thunk section with reloc to another bfd.  */
                   1524:                        blhe = bfd_link_hash_lookup (link_info.hash,
                   1525:                                                     s->name,
                   1526:                                                     FALSE, FALSE, TRUE);
                   1527:
                   1528:                        if (blhe == NULL
                   1529:                            || blhe->type != bfd_link_hash_defined)
                   1530:                          continue;
                   1531:
                   1532:                        other_bfd_filename
                   1533:                          = blhe->u.def.section->owner->my_archive
                   1534:                            ? bfd_get_filename (blhe->u.def.section->owner->my_archive)
                   1535:                            : bfd_get_filename (blhe->u.def.section->owner);
                   1536:
                   1537:                        if (filename_cmp (bfd_get_filename
                   1538:                                            (is->the_bfd->my_archive),
                   1539:                                          other_bfd_filename) == 0)
                   1540:                          continue;
                   1541:
                   1542:                        /* Rename this implib to match the other one.  */
                   1543:                        n = xmalloc (strlen (other_bfd_filename) + 1);
                   1544:                        strcpy (n, other_bfd_filename);
                   1545:                        is->the_bfd->my_archive->filename = n;
                   1546:                      }
                   1547:
                   1548:                    free (relocs);
                   1549:                    /* Note - we do not free the symbols,
                   1550:                       they are now cached in the BFD.  */
                   1551:                  }
                   1552:              }
                   1553:          }
                   1554:       }
                   1555:   }
                   1556:
                   1557:   {
                   1558:     int is_ms_arch = 0;
                   1559:     bfd *cur_arch = 0;
                   1560:     lang_input_statement_type *is2;
                   1561:     lang_input_statement_type *is3;
                   1562:
                   1563:     /* Careful - this is a shell script.  Watch those dollar signs! */
                   1564:     /* Microsoft import libraries have every member named the same,
                   1565:        and not in the right order for us to link them correctly.  We
                   1566:        must detect these and rename the members so that they'll link
                   1567:        correctly.  There are three types of objects: the head, the
                   1568:        thunks, and the sentinel(s).  The head is easy; it's the one
                   1569:        with idata2.  We assume that the sentinels won't have relocs,
                   1570:        and the thunks will.  It's easier than checking the symbol
                   1571:        table for external references.  */
                   1572:     LANG_FOR_EACH_INPUT_STATEMENT (is)
                   1573:       {
                   1574:        if (is->the_bfd->my_archive)
                   1575:          {
                   1576:            char *pnt;
                   1577:            bfd *arch = is->the_bfd->my_archive;
                   1578:
                   1579:            if (cur_arch != arch)
                   1580:              {
                   1581:                cur_arch = arch;
                   1582:                is_ms_arch = 1;
                   1583:
                   1584:                for (is3 = is;
                   1585:                     is3 && is3->the_bfd->my_archive == arch;
                   1586:                     is3 = (lang_input_statement_type *) is3->next)
                   1587:                  {
                   1588:                    /* A MS dynamic import library can also contain static
                   1589:                       members, so look for the first element with a .dll
                   1590:                       extension, and use that for the remainder of the
                   1591:                       comparisons.  */
                   1592:                    pnt = strrchr (is3->the_bfd->filename, '.');
                   1593:                    if (pnt != NULL && filename_cmp (pnt, ".dll") == 0)
                   1594:                      break;
                   1595:                  }
                   1596:
                   1597:                if (is3 == NULL)
                   1598:                  is_ms_arch = 0;
                   1599:                else
                   1600:                  {
                   1601:                    /* OK, found one.  Now look to see if the remaining
                   1602:                       (dynamic import) members use the same name.  */
                   1603:                    for (is2 = is;
                   1604:                         is2 && is2->the_bfd->my_archive == arch;
                   1605:                         is2 = (lang_input_statement_type *) is2->next)
                   1606:                      {
                   1607:                        /* Skip static members, ie anything with a .obj
                   1608:                           extension.  */
                   1609:                        pnt = strrchr (is2->the_bfd->filename, '.');
                   1610:                        if (pnt != NULL && filename_cmp (pnt, ".obj") == 0)
                   1611:                          continue;
                   1612:
                   1613:                        if (filename_cmp (is3->the_bfd->filename,
                   1614:                                          is2->the_bfd->filename))
                   1615:                          {
                   1616:                            is_ms_arch = 0;
                   1617:                            break;
                   1618:                          }
                   1619:                      }
                   1620:                  }
                   1621:              }
                   1622:
                   1623:            /* This fragment might have come from an .obj file in a Microsoft
                   1624:               import, and not an actual import record. If this is the case,
                   1625:               then leave the filename alone.  */
                   1626:            pnt = strrchr (is->the_bfd->filename, '.');
                   1627:
                   1628:            if (is_ms_arch && (filename_cmp (pnt, ".dll") == 0))
                   1629:              {
                   1630:                int idata2 = 0, reloc_count=0;
                   1631:                asection *sec;
                   1632:                char *new_name, seq;
                   1633:
                   1634:                for (sec = is->the_bfd->sections; sec; sec = sec->next)
                   1635:                  {
                   1636:                    if (strcmp (sec->name, ".idata\$2") == 0)
                   1637:                      idata2 = 1;
                   1638:                    reloc_count += sec->reloc_count;
                   1639:                  }
                   1640:
                   1641:                if (idata2) /* .idata2 is the TOC */
                   1642:                  seq = 'a';
                   1643:                else if (reloc_count > 0) /* thunks */
                   1644:                  seq = 'b';
                   1645:                else /* sentinel */
                   1646:                  seq = 'c';
                   1647:
                   1648:                new_name = xmalloc (strlen (is->the_bfd->filename) + 3);
                   1649:                sprintf (new_name, "%s.%c", is->the_bfd->filename, seq);
                   1650:                is->the_bfd->filename = new_name;
                   1651:
                   1652:                new_name = xmalloc (strlen (is->filename) + 3);
                   1653:                sprintf (new_name, "%s.%c", is->filename, seq);
                   1654:                is->filename = new_name;
                   1655:              }
                   1656:          }
                   1657:       }
                   1658:   }
                   1659:
                   1660:   {
                   1661:     /* The following chunk of code tries to identify jump stubs in
                   1662:        import libraries which are dead code and eliminates them
                   1663:        from the final link. For each exported symbol <sym>, there
                   1664:        is a object file in the import library with a .text section
                   1665:        and several .idata\$* sections. The .text section contains the
                   1666:        symbol definition for <sym> which is a jump stub of the form
                   1667:        jmp *__imp_<sym>. The .idata\$5 contains the symbol definition
                   1668:        for __imp_<sym> which is the address of the slot for <sym> in
                   1669:        the import address table. When a symbol is imported explicitly
                   1670:        using __declspec(dllimport) declaration, the compiler generates
                   1671:        a reference to __imp_<sym> which directly resolves to the
                   1672:        symbol in .idata\$5, in which case the jump stub code is not
                   1673:        needed. The following code tries to identify jump stub sections
                   1674:        in import libraries which are not referred to by anyone and
                   1675:        marks them for exclusion from the final link.  */
                   1676:     LANG_FOR_EACH_INPUT_STATEMENT (is)
                   1677:       {
                   1678:        if (is->the_bfd->my_archive)
                   1679:          {
                   1680:            int is_imp = 0;
                   1681:            asection *sec, *stub_sec = NULL;
                   1682:
                   1683:            /* See if this is an import library thunk.  */
                   1684:            for (sec = is->the_bfd->sections; sec; sec = sec->next)
                   1685:              {
                   1686:                if (strncmp (sec->name, ".idata\$", 7) == 0)
                   1687:                  is_imp = 1;
                   1688:                /* The section containing the jmp stub has code
                   1689:                   and has a reloc.  */
                   1690:                if ((sec->flags & SEC_CODE) && sec->reloc_count)
                   1691:                  stub_sec = sec;
                   1692:              }
                   1693:
                   1694:            if (is_imp && stub_sec)
                   1695:              {
                   1696:                asymbol **symbols;
                   1697:                long nsyms, src_count;
                   1698:                struct bfd_link_hash_entry * blhe;
                   1699:
                   1700:                if (!bfd_generic_link_read_symbols (is->the_bfd))
                   1701:                  {
1.5.2.1 ! martin   1702:                    einfo (_("%F%P: %pB: could not read symbols: %E\n"),
1.1       christos 1703:                           is->the_bfd);
                   1704:                    return;
                   1705:                  }
                   1706:                symbols = bfd_get_outsymbols (is->the_bfd);
                   1707:                nsyms = bfd_get_symcount (is->the_bfd);
                   1708:
                   1709:                for (src_count = 0; src_count < nsyms; src_count++)
                   1710:                  {
                   1711:                    if (symbols[src_count]->section->id == stub_sec->id)
                   1712:                      {
                   1713:                        /* This symbol belongs to the section containing
                   1714:                           the stub.  */
                   1715:                        blhe = bfd_link_hash_lookup (link_info.hash,
                   1716:                                                     symbols[src_count]->name,
                   1717:                                                     FALSE, FALSE, TRUE);
                   1718:                        /* If the symbol in the stub section has no other
                   1719:                           undefined references, exclude the stub section
                   1720:                           from the final link.  */
                   1721:                        if (blhe != NULL
                   1722:                            && blhe->type == bfd_link_hash_defined
                   1723:                            && blhe->u.undef.next == NULL
                   1724:                            && blhe != link_info.hash->undefs_tail)
                   1725:                          stub_sec->flags |= SEC_EXCLUDE;
                   1726:                      }
                   1727:                  }
                   1728:              }
                   1729:          }
                   1730:       }
                   1731:   }
                   1732: }
                   1733: 
                   1734: static void
                   1735: gld_${EMULATION_NAME}_before_allocation (void)
                   1736: {
                   1737: #ifdef TARGET_IS_ppcpe
                   1738:   /* Here we rummage through the found bfds to collect toc information.  */
                   1739:   {
                   1740:     LANG_FOR_EACH_INPUT_STATEMENT (is)
                   1741:       {
                   1742:        if (!ppc_process_before_allocation (is->the_bfd, &link_info))
                   1743:          {
                   1744:            /* xgettext:c-format */
1.5.2.1 ! martin   1745:            einfo (_("%P: errors encountered processing file %s\n"), is->filename);
1.1       christos 1746:          }
                   1747:       }
                   1748:   }
                   1749:
                   1750:   /* We have seen it all. Allocate it, and carry on.  */
                   1751:   ppc_allocate_toc_section (&link_info);
                   1752: #endif /* TARGET_IS_ppcpe */
                   1753:
1.5.2.1 ! martin   1754: #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_wince_pe)
1.1       christos 1755:   /* FIXME: we should be able to set the size of the interworking stub
                   1756:      section.
                   1757:
                   1758:      Here we rummage through the found bfds to collect glue
                   1759:      information.  FIXME: should this be based on a command line
                   1760:      option?  krk@cygnus.com.  */
                   1761:   {
                   1762:     LANG_FOR_EACH_INPUT_STATEMENT (is)
                   1763:       {
                   1764:        if (! bfd_arm_process_before_allocation
                   1765:            (is->the_bfd, & link_info, support_old_code))
                   1766:          {
                   1767:            /* xgettext:c-format */
1.5.2.1 ! martin   1768:            einfo (_("%P: errors encountered processing file %s for interworking\n"),
1.1       christos 1769:                   is->filename);
                   1770:          }
                   1771:       }
                   1772:   }
                   1773:
                   1774:   /* We have seen it all. Allocate it, and carry on.  */
                   1775:   bfd_arm_allocate_interworking_sections (& link_info);
1.5.2.1 ! martin   1776: #endif /* TARGET_IS_armpe || TARGET_IS_arm_wince_pe */
1.1       christos 1777:
                   1778:   before_allocation_default ();
                   1779: }
                   1780: 
                   1781: #ifdef DLL_SUPPORT
                   1782: /* This is called when an input file isn't recognized as a BFD.  We
                   1783:    check here for .DEF files and pull them in automatically.  */
                   1784:
                   1785: static int
                   1786: saw_option (char *option)
                   1787: {
                   1788:   int i;
                   1789:
                   1790:   for (i = 0; init[i].ptr; i++)
                   1791:     if (strcmp (GET_INIT_SYMBOL_NAME (i), option) == 0)
                   1792:       return init[i].inited;
                   1793:   return 0;
                   1794: }
                   1795: #endif /* DLL_SUPPORT */
                   1796:
                   1797: static bfd_boolean
                   1798: gld_${EMULATION_NAME}_unrecognized_file (lang_input_statement_type *entry ATTRIBUTE_UNUSED)
                   1799: {
                   1800: #ifdef DLL_SUPPORT
                   1801:   const char *ext = entry->filename + strlen (entry->filename) - 4;
                   1802:
                   1803:   if (filename_cmp (ext, ".def") == 0 || filename_cmp (ext, ".DEF") == 0)
                   1804:     {
                   1805:       pe_def_file = def_file_parse (entry->filename, pe_def_file);
                   1806:
                   1807:       if (pe_def_file)
                   1808:        {
                   1809:          int i, buflen=0, len;
                   1810:          char *buf;
                   1811:
                   1812:          for (i = 0; i < pe_def_file->num_exports; i++)
                   1813:            {
                   1814:              len = strlen (pe_def_file->exports[i].internal_name);
                   1815:              if (buflen < len + 2)
                   1816:                buflen = len + 2;
                   1817:            }
                   1818:
                   1819:          buf = xmalloc (buflen);
                   1820:
                   1821:          for (i = 0; i < pe_def_file->num_exports; i++)
                   1822:            {
                   1823:              struct bfd_link_hash_entry *h;
                   1824:
                   1825:              sprintf (buf, "%s%s", U (""),
1.5.2.1 ! martin   1826:                       pe_def_file->exports[i].internal_name);
1.1       christos 1827:
                   1828:              h = bfd_link_hash_lookup (link_info.hash, buf, TRUE, TRUE, TRUE);
                   1829:              if (h == (struct bfd_link_hash_entry *) NULL)
1.5.2.1 ! martin   1830:                einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
1.1       christos 1831:              if (h->type == bfd_link_hash_new)
                   1832:                {
                   1833:                  h->type = bfd_link_hash_undefined;
                   1834:                  h->u.undef.abfd = NULL;
                   1835:                  bfd_link_add_undef (link_info.hash, h);
                   1836:                }
                   1837:            }
                   1838:          free (buf);
                   1839:
                   1840:          /* def_file_print (stdout, pe_def_file); */
                   1841:          if (pe_def_file->is_dll == 1)
1.3       christos 1842:            link_info.type = type_dll;
1.1       christos 1843:
                   1844:          if (pe_def_file->base_address != (bfd_vma)(-1))
                   1845:            {
                   1846:              pe.ImageBase
                   1847:                = pe_data (link_info.output_bfd)->pe_opthdr.ImageBase
                   1848:                = init[IMAGEBASEOFF].value
                   1849:                = pe_def_file->base_address;
                   1850:              init[IMAGEBASEOFF].inited = 1;
                   1851:              if (image_base_statement)
                   1852:                image_base_statement->exp
                   1853:                  = exp_assign ("__image_base__", exp_intop (pe.ImageBase),
                   1854:                                FALSE);
                   1855:            }
                   1856:
                   1857:          if (pe_def_file->stack_reserve != -1
                   1858:              && ! saw_option ("__size_of_stack_reserve__"))
                   1859:            {
                   1860:              pe.SizeOfStackReserve = pe_def_file->stack_reserve;
                   1861:              if (pe_def_file->stack_commit != -1)
                   1862:                pe.SizeOfStackCommit = pe_def_file->stack_commit;
                   1863:            }
                   1864:          if (pe_def_file->heap_reserve != -1
                   1865:              && ! saw_option ("__size_of_heap_reserve__"))
                   1866:            {
                   1867:              pe.SizeOfHeapReserve = pe_def_file->heap_reserve;
                   1868:              if (pe_def_file->heap_commit != -1)
                   1869:                pe.SizeOfHeapCommit = pe_def_file->heap_commit;
                   1870:            }
                   1871:          return TRUE;
                   1872:        }
                   1873:     }
                   1874: #endif
                   1875:   return FALSE;
                   1876: }
                   1877:
                   1878: static bfd_boolean
                   1879: gld_${EMULATION_NAME}_recognized_file (lang_input_statement_type *entry ATTRIBUTE_UNUSED)
                   1880: {
                   1881: #ifdef DLL_SUPPORT
                   1882: #ifdef TARGET_IS_i386pe
                   1883:   pe_dll_id_target ("pei-i386");
                   1884: #endif
                   1885: #ifdef TARGET_IS_shpe
                   1886:   pe_dll_id_target ("pei-shl");
                   1887: #endif
                   1888: #ifdef TARGET_IS_armpe
                   1889:   pe_dll_id_target ("pei-arm-little");
                   1890: #endif
                   1891: #ifdef TARGET_IS_arm_wince_pe
                   1892:   pe_dll_id_target ("pei-arm-wince-little");
                   1893: #endif
                   1894:   if (pe_bfd_is_dll (entry->the_bfd))
                   1895:     return pe_implied_import_dll (entry->filename);
                   1896: #endif
                   1897:   return FALSE;
                   1898: }
                   1899:
                   1900: static void
                   1901: gld_${EMULATION_NAME}_finish (void)
                   1902: {
1.5.2.1 ! martin   1903: #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_wince_pe)
1.1       christos 1904:   struct bfd_link_hash_entry * h;
                   1905:
                   1906:   if (thumb_entry_symbol != NULL)
                   1907:     {
                   1908:       h = bfd_link_hash_lookup (link_info.hash, thumb_entry_symbol,
                   1909:                                FALSE, FALSE, TRUE);
                   1910:
                   1911:       if (h != (struct bfd_link_hash_entry *) NULL
                   1912:          && (h->type == bfd_link_hash_defined
                   1913:              || h->type == bfd_link_hash_defweak)
                   1914:          && h->u.def.section->output_section != NULL)
                   1915:        {
                   1916:          static char buffer[32];
                   1917:          bfd_vma val;
                   1918:
                   1919:          /* Special procesing is required for a Thumb entry symbol.  The
                   1920:             bottom bit of its address must be set.  */
                   1921:          val = (h->u.def.value
                   1922:                 + bfd_get_section_vma (link_info.output_bfd,
                   1923:                                        h->u.def.section->output_section)
                   1924:                 + h->u.def.section->output_offset);
                   1925:
                   1926:          val |= 1;
                   1927:
                   1928:          /* Now convert this value into a string and store it in entry_symbol
                   1929:             where the lang_finish() function will pick it up.  */
                   1930:          buffer[0] = '0';
                   1931:          buffer[1] = 'x';
                   1932:
                   1933:          sprintf_vma (buffer + 2, val);
                   1934:
                   1935:          if (entry_symbol.name != NULL && entry_from_cmdline)
                   1936:            einfo (_("%P: warning: '--thumb-entry %s' is overriding '-e %s'\n"),
                   1937:                   thumb_entry_symbol, entry_symbol.name);
                   1938:          entry_symbol.name = buffer;
                   1939:        }
                   1940:       else
                   1941:        einfo (_("%P: warning: cannot find thumb start symbol %s\n"), thumb_entry_symbol);
                   1942:     }
1.5.2.1 ! martin   1943: #endif /* defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_wince_pe) */
1.1       christos 1944:
                   1945:   finish_default ();
                   1946:
                   1947: #ifdef DLL_SUPPORT
1.3       christos 1948:   if (bfd_link_pic (&link_info)
                   1949: #if !defined(TARGET_IS_shpe)
                   1950:       || (!bfd_link_relocatable (&link_info)
                   1951:          && pe_def_file->num_exports != 0)
1.1       christos 1952: #endif
                   1953:     )
                   1954:     {
                   1955:       pe_dll_fill_sections (link_info.output_bfd, &link_info);
1.5.2.1 ! martin   1956:       if (command_line.out_implib_filename)
        !          1957:        pe_dll_generate_implib (pe_def_file, command_line.out_implib_filename,
        !          1958:                                &link_info);
1.1       christos 1959:     }
1.3       christos 1960: #if defined(TARGET_IS_shpe)
1.1       christos 1961:   /* ARM doesn't need relocs.  */
                   1962:   else
                   1963:     {
                   1964:       pe_exe_fill_sections (link_info.output_bfd, &link_info);
                   1965:     }
                   1966: #endif
                   1967:
                   1968:   if (pe_out_def_filename)
                   1969:     pe_dll_generate_def_file (pe_out_def_filename);
                   1970: #endif /* DLL_SUPPORT */
                   1971:
                   1972:   /* I don't know where .idata gets set as code, but it shouldn't be.  */
                   1973:   {
                   1974:     asection *asec = bfd_get_section_by_name (link_info.output_bfd, ".idata");
                   1975:
                   1976:     if (asec)
                   1977:       {
                   1978:        asec->flags &= ~SEC_CODE;
                   1979:        asec->flags |= SEC_DATA;
                   1980:       }
                   1981:   }
                   1982: }
                   1983:
                   1984: 
                   1985: /* Place an orphan section.
                   1986:
                   1987:    We use this to put sections in a reasonable place in the file, and
                   1988:    to ensure that they are aligned as required.
                   1989:
                   1990:    We handle grouped sections here as well.  A section named .foo\$nn
                   1991:    goes into the output section .foo.  All grouped sections are sorted
                   1992:    by name.
                   1993:
                   1994:    Grouped sections for the default sections are handled by the
                   1995:    default linker script using wildcards, and are sorted by
                   1996:    sort_sections.  */
                   1997:
                   1998: static lang_output_section_statement_type *
                   1999: gld_${EMULATION_NAME}_place_orphan (asection *s,
                   2000:                                    const char *secname,
                   2001:                                    int constraint)
                   2002: {
                   2003:   const char *orig_secname = secname;
                   2004:   char *dollar = NULL;
                   2005:   lang_output_section_statement_type *os;
                   2006:   lang_statement_list_type add_child;
                   2007:   lang_output_section_statement_type *match_by_name = NULL;
                   2008:   lang_statement_union_type **pl;
                   2009:
                   2010:   /* Look through the script to see where to place this section.  */
1.3       christos 2011:   if (!bfd_link_relocatable (&link_info)
1.1       christos 2012:       && (dollar = strchr (secname, '\$')) != NULL)
                   2013:     {
                   2014:       size_t len = dollar - secname;
                   2015:       char *newname = xmalloc (len + 1);
                   2016:       memcpy (newname, secname, len);
                   2017:       newname[len] = '\0';
                   2018:       secname = newname;
                   2019:     }
                   2020:
                   2021:   lang_list_init (&add_child);
                   2022:
                   2023:   os = NULL;
                   2024:   if (constraint == 0)
                   2025:     for (os = lang_output_section_find (secname);
                   2026:         os != NULL;
                   2027:         os = next_matching_output_section_statement (os, 0))
                   2028:       {
                   2029:        /* If we don't match an existing output section, tell
                   2030:           lang_insert_orphan to create a new output section.  */
                   2031:        constraint = SPECIAL;
                   2032:
                   2033:        if (os->bfd_section != NULL
                   2034:            && (os->bfd_section->flags == 0
                   2035:                || ((s->flags ^ os->bfd_section->flags)
                   2036:                    & (SEC_LOAD | SEC_ALLOC)) == 0))
                   2037:          {
                   2038:            /* We already have an output section statement with this
                   2039:               name, and its bfd section has compatible flags.
                   2040:               If the section already exists but does not have any flags set,
                   2041:               then it has been created by the linker, probably as a result of
                   2042:               a --section-start command line switch.  */
                   2043:            lang_add_section (&add_child, s, NULL, os);
                   2044:            break;
                   2045:          }
                   2046:
                   2047:        /* Save unused output sections in case we can match them
                   2048:           against orphans later.  */
                   2049:        if (os->bfd_section == NULL)
                   2050:          match_by_name = os;
                   2051:       }
                   2052:
                   2053:   /* If we didn't match an active output section, see if we matched an
                   2054:      unused one and use that.  */
                   2055:   if (os == NULL && match_by_name)
                   2056:     {
                   2057:       lang_add_section (&match_by_name->children, s, NULL, match_by_name);
                   2058:       return match_by_name;
                   2059:     }
                   2060:
                   2061:   if (os == NULL)
                   2062:     {
                   2063:       static struct orphan_save hold[] =
                   2064:        {
                   2065:          { ".text",
                   2066:            SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE,
                   2067:            0, 0, 0, 0 },
                   2068:          { ".idata",
                   2069:            SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
                   2070:            0, 0, 0, 0 },
                   2071:          { ".rdata",
                   2072:            SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
                   2073:            0, 0, 0, 0 },
                   2074:          { ".data",
                   2075:            SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA,
                   2076:            0, 0, 0, 0 },
                   2077:          { ".bss",
                   2078:            SEC_ALLOC,
                   2079:            0, 0, 0, 0 }
                   2080:        };
                   2081:       enum orphan_save_index
                   2082:        {
                   2083:          orphan_text = 0,
                   2084:          orphan_idata,
                   2085:          orphan_rodata,
                   2086:          orphan_data,
                   2087:          orphan_bss
                   2088:        };
                   2089:       static int orphan_init_done = 0;
                   2090:       struct orphan_save *place;
                   2091:       lang_output_section_statement_type *after;
                   2092:       etree_type *address;
1.3       christos 2093:       flagword flags;
                   2094:       asection *nexts;
1.1       christos 2095:
                   2096:       if (!orphan_init_done)
                   2097:        {
                   2098:          struct orphan_save *ho;
                   2099:          for (ho = hold; ho < hold + sizeof (hold) / sizeof (hold[0]); ++ho)
                   2100:            if (ho->name != NULL)
                   2101:              {
                   2102:                ho->os = lang_output_section_find (ho->name);
                   2103:                if (ho->os != NULL && ho->os->flags == 0)
                   2104:                  ho->os->flags = ho->flags;
                   2105:              }
                   2106:          orphan_init_done = 1;
                   2107:        }
                   2108:
1.3       christos 2109:       flags = s->flags;
                   2110:       if (!bfd_link_relocatable (&link_info))
                   2111:        {
                   2112:          nexts = s;
                   2113:          while ((nexts = bfd_get_next_section_by_name (nexts->owner,
                   2114:                                                        nexts)))
                   2115:            if (nexts->output_section == NULL
                   2116:                && (nexts->flags & SEC_EXCLUDE) == 0
                   2117:                && ((nexts->flags ^ flags) & (SEC_LOAD | SEC_ALLOC)) == 0
                   2118:                && (nexts->owner->flags & DYNAMIC) == 0
                   2119:                && nexts->owner->usrdata != NULL
                   2120:                && !(((lang_input_statement_type *) nexts->owner->usrdata)
                   2121:                     ->flags.just_syms))
                   2122:              flags = (((flags ^ SEC_READONLY)
                   2123:                        | (nexts->flags ^ SEC_READONLY))
                   2124:                       ^ SEC_READONLY);
                   2125:        }
                   2126:
1.1       christos 2127:       /* Try to put the new output section in a reasonable place based
                   2128:         on the section name and section flags.  */
                   2129:
                   2130:       place = NULL;
1.3       christos 2131:       if ((flags & SEC_ALLOC) == 0)
1.1       christos 2132:        ;
1.3       christos 2133:       else if ((flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
1.1       christos 2134:        place = &hold[orphan_bss];
1.3       christos 2135:       else if ((flags & SEC_READONLY) == 0)
1.1       christos 2136:        place = &hold[orphan_data];
1.3       christos 2137:       else if ((flags & SEC_CODE) == 0)
1.1       christos 2138:        {
                   2139:          place = (!strncmp (secname, ".idata\$", 7) ? &hold[orphan_idata]
                   2140:                                                     : &hold[orphan_rodata]);
                   2141:        }
                   2142:       else
                   2143:        place = &hold[orphan_text];
                   2144:
                   2145:       after = NULL;
                   2146:       if (place != NULL)
                   2147:        {
                   2148:          if (place->os == NULL)
                   2149:            place->os = lang_output_section_find (place->name);
                   2150:          after = place->os;
                   2151:          if (after == NULL)
1.3       christos 2152:            after = lang_output_section_find_by_flags (s, flags, &place->os,
                   2153:                                                       NULL);
1.1       christos 2154:          if (after == NULL)
                   2155:            /* *ABS* is always the first output section statement.  */
                   2156:            after = (&lang_output_section_statement.head
                   2157:                     ->output_section_statement);
                   2158:        }
                   2159:
                   2160:       /* All sections in an executable must be aligned to a page boundary.
                   2161:         In a relocatable link, just preserve the incoming alignment; the
                   2162:         address is discarded by lang_insert_orphan in that case, anyway.  */
                   2163:       address = exp_unop (ALIGN_K, exp_nameop (NAME, "__section_alignment__"));
                   2164:       os = lang_insert_orphan (s, secname, constraint, after, place, address,
                   2165:                               &add_child);
1.3       christos 2166:       if (bfd_link_relocatable (&link_info))
1.1       christos 2167:        {
                   2168:          os->section_alignment = s->alignment_power;
                   2169:          os->bfd_section->alignment_power = s->alignment_power;
                   2170:        }
                   2171:     }
                   2172:
                   2173:   /* If the section name has a '\$', sort it with the other '\$'
                   2174:      sections.  */
                   2175:   for (pl = &os->children.head; *pl != NULL; pl = &(*pl)->header.next)
                   2176:     {
                   2177:       lang_input_section_type *ls;
                   2178:       const char *lname;
                   2179:
                   2180:       if ((*pl)->header.type != lang_input_section_enum)
                   2181:        continue;
                   2182:
                   2183:       ls = &(*pl)->input_section;
                   2184:
                   2185:       lname = bfd_get_section_name (ls->section->owner, ls->section);
                   2186:       if (strchr (lname, '\$') != NULL
                   2187:          && (dollar == NULL || strcmp (orig_secname, lname) < 0))
                   2188:        break;
                   2189:     }
                   2190:
                   2191:   if (add_child.head != NULL)
                   2192:     {
                   2193:       *add_child.tail = *pl;
                   2194:       *pl = add_child.head;
                   2195:     }
                   2196:
                   2197:   return os;
                   2198: }
                   2199:
                   2200: static bfd_boolean
                   2201: gld_${EMULATION_NAME}_open_dynamic_archive
                   2202:   (const char *arch ATTRIBUTE_UNUSED,
                   2203:    search_dirs_type *search,
                   2204:    lang_input_statement_type *entry)
                   2205: {
                   2206:   static const struct
                   2207:     {
                   2208:       const char * format;
                   2209:       bfd_boolean use_prefix;
                   2210:     }
                   2211:   libname_fmt [] =
                   2212:     {
                   2213:       /* Preferred explicit import library for dll's.  */
                   2214:       { "lib%s.dll.a", FALSE },
                   2215:       /* Alternate explicit import library for dll's.  */
                   2216:       { "%s.dll.a", FALSE },
                   2217:       /* "libfoo.a" could be either an import lib or a static lib.
1.5.2.1 ! martin   2218:         For backwards compatibility, libfoo.a needs to precede
        !          2219:         libfoo.dll and foo.dll in the search.  */
1.1       christos 2220:       { "lib%s.a", FALSE },
                   2221:       /* The 'native' spelling of an import lib name is "foo.lib".  */
                   2222:       { "%s.lib", FALSE },
1.5.2.1 ! martin   2223:       /* PR 22948 - Check for an import library.  */
        !          2224:       { "lib%s.lib", FALSE },
1.1       christos 2225: #ifdef DLL_SUPPORT
                   2226:       /* Try "<prefix>foo.dll" (preferred dll name, if specified).  */
                   2227:       {        "%s%s.dll", TRUE },
                   2228: #endif
                   2229:       /* Try "libfoo.dll" (default preferred dll name).  */
                   2230:       {        "lib%s.dll", FALSE },
                   2231:       /* Finally try 'native' dll name "foo.dll".  */
                   2232:       {  "%s.dll", FALSE },
                   2233:       /* Note: If adding more formats to this table, make sure to check to
                   2234:         see if their length is longer than libname_fmt[0].format, and if
                   2235:         so, update the call to xmalloc() below.  */
                   2236:       { NULL, FALSE }
                   2237:     };
                   2238:   static unsigned int format_max_len = 0;
                   2239:   const char * filename;
                   2240:   char * full_string;
                   2241:   char * base_string;
                   2242:   unsigned int i;
                   2243:
                   2244:
1.3       christos 2245:   if (! entry->flags.maybe_archive || entry->flags.full_name_provided)
1.1       christos 2246:     return FALSE;
                   2247:
                   2248:   filename = entry->filename;
                   2249:
                   2250:   if (format_max_len == 0)
                   2251:     /* We need to allow space in the memory that we are going to allocate
                   2252:        for the characters in the format string.  Since the format array is
                   2253:        static we only need to calculate this information once.  In theory
                   2254:        this value could also be computed statically, but this introduces
                   2255:        the possibility for a discrepancy and hence a possible memory
                   2256:        corruption.  The lengths we compute here will be too long because
                   2257:        they will include any formating characters (%s) in the strings, but
                   2258:        this will not matter.  */
                   2259:     for (i = 0; libname_fmt[i].format; i++)
                   2260:       if (format_max_len < strlen (libname_fmt[i].format))
                   2261:        format_max_len = strlen (libname_fmt[i].format);
                   2262:
                   2263:   full_string = xmalloc (strlen (search->name)
                   2264:                         + strlen (filename)
                   2265:                         + format_max_len
                   2266: #ifdef DLL_SUPPORT
                   2267:                         + (pe_dll_search_prefix
                   2268:                            ? strlen (pe_dll_search_prefix) : 0)
                   2269: #endif
                   2270:                         /* Allow for the terminating NUL and for the path
                   2271:                            separator character that is inserted between
                   2272:                            search->name and the start of the format string.  */
                   2273:                         + 2);
                   2274:
                   2275:   sprintf (full_string, "%s/", search->name);
                   2276:   base_string = full_string + strlen (full_string);
                   2277:
                   2278:   for (i = 0; libname_fmt[i].format; i++)
                   2279:     {
                   2280: #ifdef DLL_SUPPORT
                   2281:       if (libname_fmt[i].use_prefix)
                   2282:        {
                   2283:          if (!pe_dll_search_prefix)
                   2284:            continue;
                   2285:          sprintf (base_string, libname_fmt[i].format, pe_dll_search_prefix, filename);
                   2286:        }
                   2287:       else
                   2288: #endif
                   2289:        sprintf (base_string, libname_fmt[i].format, filename);
                   2290:
                   2291:       if (ldfile_try_open_bfd (full_string, entry))
                   2292:        break;
                   2293:     }
                   2294:
                   2295:   if (!libname_fmt[i].format)
                   2296:     {
                   2297:       free (full_string);
                   2298:       return FALSE;
                   2299:     }
                   2300:
                   2301:   entry->filename = full_string;
                   2302:
                   2303:   return TRUE;
                   2304: }
                   2305:
                   2306: static int
                   2307: gld_${EMULATION_NAME}_find_potential_libraries
                   2308:   (char *name, lang_input_statement_type *entry)
                   2309: {
                   2310:   return ldfile_open_file_search (name, entry, "", ".lib");
                   2311: }
                   2312: 
                   2313: static char *
                   2314: gld_${EMULATION_NAME}_get_script (int *isfile)
                   2315: EOF
                   2316: # Scripts compiled in.
                   2317: # sed commands to quote an ld script as a C string.
                   2318: sc="-f stringify.sed"
                   2319:
                   2320: fragment <<EOF
                   2321: {
                   2322:   *isfile = 0;
                   2323:
1.3       christos 2324:   if (bfd_link_relocatable (&link_info) && config.build_constructors)
1.1       christos 2325:     return
                   2326: EOF
                   2327: sed $sc ldscripts/${EMULATION_NAME}.xu                 >> e${EMULATION_NAME}.c
1.3       christos 2328: echo '  ; else if (bfd_link_relocatable (&link_info)) return' >> e${EMULATION_NAME}.c
1.1       christos 2329: sed $sc ldscripts/${EMULATION_NAME}.xr                 >> e${EMULATION_NAME}.c
                   2330: echo '  ; else if (!config.text_read_only) return'     >> e${EMULATION_NAME}.c
                   2331: sed $sc ldscripts/${EMULATION_NAME}.xbn                        >> e${EMULATION_NAME}.c
                   2332: echo '  ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
                   2333: sed $sc ldscripts/${EMULATION_NAME}.xn                 >> e${EMULATION_NAME}.c
                   2334: if test -n "$GENERATE_AUTO_IMPORT_SCRIPT" ; then
                   2335: echo '  ; else if (link_info.pei386_auto_import == 1 && (MERGE_RDATA_V2 || link_info.pei386_runtime_pseudo_reloc != 2)) return'        >> e${EMULATION_NAME}.c
                   2336: sed $sc ldscripts/${EMULATION_NAME}.xa                 >> e${EMULATION_NAME}.c
                   2337: fi
                   2338: echo '  ; else return'                                 >> e${EMULATION_NAME}.c
                   2339: sed $sc ldscripts/${EMULATION_NAME}.x                  >> e${EMULATION_NAME}.c
                   2340: echo '; }'                                             >> e${EMULATION_NAME}.c
                   2341:
                   2342: fragment <<EOF
                   2343:
                   2344:
                   2345: struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
                   2346: {
                   2347:   gld_${EMULATION_NAME}_before_parse,
                   2348:   syslib_default,
                   2349:   hll_default,
                   2350:   gld_${EMULATION_NAME}_after_parse,
                   2351:   gld_${EMULATION_NAME}_after_open,
1.5.2.1 ! martin   2352:   after_check_relocs_default,
1.1       christos 2353:   after_allocation_default,
                   2354:   set_output_arch_default,
                   2355:   ldemul_default_target,
                   2356:   gld_${EMULATION_NAME}_before_allocation,
                   2357:   gld_${EMULATION_NAME}_get_script,
                   2358:   "${EMULATION_NAME}",
                   2359:   "${OUTPUT_FORMAT}",
                   2360:   gld_${EMULATION_NAME}_finish,
                   2361:   NULL, /* Create output section statements.  */
                   2362:   gld_${EMULATION_NAME}_open_dynamic_archive,
                   2363:   gld_${EMULATION_NAME}_place_orphan,
                   2364:   gld_${EMULATION_NAME}_set_symbols,
                   2365:   NULL, /* parse_args */
                   2366:   gld${EMULATION_NAME}_add_options,
                   2367:   gld${EMULATION_NAME}_handle_option,
                   2368:   gld_${EMULATION_NAME}_unrecognized_file,
                   2369:   gld_${EMULATION_NAME}_list_options,
                   2370:   gld_${EMULATION_NAME}_recognized_file,
                   2371:   gld_${EMULATION_NAME}_find_potential_libraries,
1.3       christos 2372:   NULL,        /* new_vers_pattern.  */
                   2373:   NULL /* extra_map_file_text.  */
1.1       christos 2374: };
                   2375: EOF

CVSweb <webmaster@jp.NetBSD.org>