| /* VMS linker wrapper. |
| Copyright (C) 2011-2015 Free Software Foundation, Inc. |
| Contributed by AdaCore |
| |
| This file is part of GCC. |
| |
| GCC is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 3, or (at your option) |
| any later version. |
| |
| GCC is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GCC; see the file COPYING3. If not see |
| <http://www.gnu.org/licenses/>. */ |
| |
| /* This program is a wrapper around the VMS linker. |
| It translates Unix style command line options into corresponding |
| VMS style qualifiers and then spawns the VMS linker. |
| |
| It is possible to build this program on UNIX but only for the purpose of |
| checking for errors. */ |
| |
| #include <stdlib.h> |
| #include <string.h> |
| #include <unistd.h> |
| #include <stdio.h> |
| |
| #include "libiberty.h" |
| #include <safe-ctype.h> |
| #include <sys/stat.h> |
| |
| /* Macro for logicals. */ |
| #define LNM__STRING 2 |
| #define LNM_C_NAMLENGTH 255 |
| #define PSL_C_SUPER 2 |
| #define PSL_C_USER 3 |
| |
| /* Local variable declarations. */ |
| static int ld_nocall_debug = 0; |
| static int ld_mkthreads = 0; |
| static int ld_upcalls = 0; |
| |
| /* verbose = 1 if -v passed. */ |
| static int verbose = 0; |
| |
| /* save_temps = 1 if -save-temps passed. */ |
| static int save_temps = 0; |
| |
| /* By default don't generate executable file if there are errors |
| in the link. Override with --noinhibit-exec. */ |
| static int inhibit_exec = 1; |
| |
| /* debug = 1 if -g passed. */ |
| static int debug = 0; |
| |
| /* By default prefer to link with static libraries. */ |
| static int staticp = 1; |
| |
| /* By default generate an executable, not a shareable image library. |
| Override with -shared. */ |
| static int share = 0; |
| |
| /* Linker command line. */ |
| static int link_cmd_maxlen = 0; |
| static char *link_cmd = 0; |
| static int link_cmd_len = 0; |
| |
| /* Keep track of filenames. */ |
| static char *sharebasename; |
| static const char *exefullfilename; |
| static const char *exefilename; |
| |
| /* Search dir list passed on command line (with -L). */ |
| static const char **search_dirs; |
| static int search_dirs_len; |
| |
| /* Local function declarations. */ |
| static void addarg (const char *); |
| static int is_regular_file (char *); |
| static char *to_host_file_spec (char *); |
| static char *locate_lib (char *); |
| static const char *expand_lib (char *); |
| static void preprocess_args (int, char **); |
| static void process_args (int, char **); |
| static void maybe_set_link_compat (void); |
| static int set_exe (const char *); |
| #ifdef VMS |
| static int translate_unix (char *, int); |
| #endif |
| |
| |
| /* Append STR to the command line to invoke the linker. |
| Expand the line as necessary to accommodate. */ |
| |
| static void |
| addarg (const char *str) |
| { |
| int l = strlen (str); |
| |
| /* Extend the line. */ |
| if (link_cmd_len + l >= link_cmd_maxlen) |
| { |
| link_cmd_maxlen = link_cmd_len + l + 1024; |
| link_cmd = XRESIZEVEC (char, link_cmd, link_cmd_maxlen); |
| } |
| |
| memcpy (link_cmd + link_cmd_len, str, l); |
| link_cmd_len += l; |
| } |
| |
| /* Check to see if NAME is a regular file, i.e. not a directory. */ |
| |
| static int |
| is_regular_file (char *name) |
| { |
| int ret; |
| struct stat statbuf; |
| |
| ret = stat (name, &statbuf); |
| return !ret && S_ISREG (statbuf.st_mode); |
| } |
| |
| #ifdef VMS |
| static char new_host_filespec [255]; |
| static char filename_buff [256]; |
| |
| /* Action routine called by decc$to_vms. NAME is a file name or |
| directory name. TYPE is unused. */ |
| |
| static int |
| translate_unix (char *name, int type ATTRIBUTE_UNUSED) |
| { |
| strcpy (filename_buff, name); |
| return 0; |
| } |
| #endif |
| |
| /* Translate a Unix syntax file specification FILESPEC into VMS syntax. |
| If indicators of VMS syntax found, return input string. |
| Return a pointer to a static buffer. */ |
| |
| static char * |
| to_host_file_spec (char *filespec) |
| { |
| #ifdef VMS |
| if (strchr (filespec, ']') || strchr (filespec, ':')) |
| { |
| /* Looks like a VMS path. */ |
| return filespec; |
| } |
| else |
| { |
| |
| strcpy (filename_buff, filespec); |
| decc$to_vms (filespec, translate_unix, 1, 1); |
| strcpy (new_host_filespec, filename_buff); |
| return new_host_filespec; |
| } |
| #else |
| return filespec; |
| #endif |
| } |
| |
| /* Locate library LIB_NAME on the library path. */ |
| |
| static char * |
| locate_lib (char *lib_name) |
| { |
| int lib_len = strlen (lib_name); |
| const char *exts[3]; |
| int i; |
| |
| if (staticp) |
| { |
| /* For static links, look for shareable image libraries last. */ |
| exts[0] = ".a"; |
| exts[1] = ".olb"; |
| exts[2] = ".exe"; |
| } |
| else |
| { |
| exts[0] = ".exe"; |
| exts[1] = ".a"; |
| exts[2] = ".olb"; |
| } |
| |
| for (i = 0; i < search_dirs_len; i++) |
| { |
| char *buf; |
| int l; |
| int j; |
| |
| l = strlen (search_dirs[i]); |
| buf = (char *)alloca (l + 4 + lib_len + 4 + 1); |
| /* Put PATH/libLIB. */ |
| memcpy (buf, search_dirs[i], l); |
| memcpy (buf + l, "/lib", 4); |
| l += 4; |
| memcpy (buf + l, lib_name, lib_len); |
| l += lib_len; |
| |
| /* Look for files with the extensions. */ |
| for (j = 0; j < 3; j++) |
| { |
| strcpy (buf + l, exts[j]); |
| if (is_regular_file (buf)) |
| return xstrdup (to_host_file_spec (buf)); |
| } |
| } |
| |
| return NULL; |
| } |
| |
| /* Given a library name NAME, i.e. foo, Look for libfoo.lib and then |
| libfoo.a in the set of directories we are allowed to search in. |
| May return NULL if the library can be discarded. */ |
| |
| static const char * |
| expand_lib (char *name) |
| { |
| char *lib_path; |
| |
| /* Discard libc. */ |
| if (strcmp (name, "c") == 0) |
| return NULL; |
| |
| /* Discard libm. No separate library for math functions. */ |
| if (strcmp (name, "m") == 0) |
| return NULL; |
| |
| /* Search on path. */ |
| lib_path = locate_lib (name); |
| if (lib_path) |
| return lib_path; |
| |
| fprintf (stderr, |
| "Couldn't locate library: lib%s.exe, lib%s.a or lib%s.olb\n", |
| name, name, name); |
| |
| exit (EXIT_FAILURE); |
| } |
| |
| /* Preprocess the number of args P_ARGC in ARGV. |
| Look for special flags, etc. that must be handled first. */ |
| |
| static void |
| preprocess_args (int argc, char **argv) |
| { |
| int i; |
| |
| /* Scan for -shared. */ |
| for (i = 1; i < argc; i++) |
| if (strcmp (argv[i], "-shared") == 0) |
| { |
| share = 1; |
| break; |
| } |
| |
| for (i = 1; i < argc; i++) |
| if (strcmp (argv[i], "-o") == 0) |
| { |
| int len; |
| |
| i++; |
| exefilename = lbasename (argv[i]); |
| exefullfilename = xstrdup (to_host_file_spec (argv[i])); |
| |
| if (share) |
| addarg(" /share="); |
| else |
| addarg (" /exe="); |
| addarg (exefullfilename); |
| |
| if (share) |
| { |
| char *ptr; |
| |
| /* Extract the basename. */ |
| ptr = strchr (argv[i], ']'); |
| if (ptr == NULL) |
| ptr = strchr (argv[i], ':'); |
| if (ptr == NULL) |
| ptr = strchr (argv[i], '/'); |
| if (ptr == NULL) |
| sharebasename = xstrdup (argv[i]); |
| else |
| sharebasename = xstrdup (ptr + 1); |
| |
| len = strlen (sharebasename); |
| if (strncasecmp (&sharebasename[len-4], ".exe", 4) == 0) |
| sharebasename[len - 4] = 0; |
| |
| /* Convert to uppercase. */ |
| for (ptr = sharebasename; *ptr; ptr++) |
| *ptr = TOUPPER (*ptr); |
| } |
| } |
| |
| if (exefullfilename == NULL && !share) |
| { |
| exefilename = "a_out.exe"; |
| exefullfilename = "a_out.exe"; |
| addarg (xstrdup (" /exe=a_out.exe")); |
| } |
| } |
| |
| /* Preprocess the number of args ARGC in ARGV. Look for |
| special flags, etc. that must be handled for the VMS linker. */ |
| |
| static void |
| process_args (int argc, char **argv) |
| { |
| int i; |
| |
| for (i = 1; i < argc; i++) |
| { |
| if (strncmp (argv[i], "-L", 2) == 0) |
| { |
| search_dirs = XRESIZEVEC(const char *, search_dirs, |
| search_dirs_len + 1); |
| search_dirs[search_dirs_len++] = &argv[i][2]; |
| } |
| |
| /* -v turns on verbose option here and is passed on to gcc. */ |
| else if (strcmp (argv[i], "-v") == 0) |
| verbose++; |
| else if (strcmp (argv[i], "--version") == 0) |
| { |
| fprintf (stdout, "VMS Linker\n"); |
| exit (EXIT_SUCCESS); |
| } |
| else if (strcmp (argv[i], "--help") == 0) |
| { |
| fprintf (stdout, "VMS Linker\n"); |
| exit (EXIT_SUCCESS); |
| } |
| else if (strcmp (argv[i], "-g0") == 0) |
| addarg ("/notraceback"); |
| else if (strncmp (argv[i], "-g", 2) == 0) |
| { |
| addarg ("/debug"); |
| debug = 1; |
| } |
| else if (strcmp (argv[i], "-static") == 0) |
| staticp = 1; |
| else if (strcmp (argv[i], "-map") == 0) |
| { |
| char *buff, *ptr; |
| |
| buff = (char *) xstrdup (exefullfilename); |
| ptr = strrchr (buff, '.'); |
| if (ptr) |
| *ptr = 0; |
| |
| strcat (buff, ".map"); |
| addarg ("/map="); |
| addarg (buff); |
| addarg (".map"); |
| addarg ("/full"); |
| |
| free (buff); |
| } |
| else if (strcmp (argv[i], "-save-temps") == 0) |
| save_temps = 1; |
| else if (strcmp (argv[i], "--noinhibit-exec") == 0) |
| inhibit_exec = 0; |
| } |
| } |
| |
| #ifdef VMS |
| typedef struct dsc |
| { |
| unsigned short len, mbz; |
| const char *adr; |
| } Descriptor; |
| |
| struct lst |
| { |
| unsigned short buflen, item_code; |
| const void *bufaddr; |
| void *retlenaddr; |
| }; |
| |
| static struct |
| { |
| struct lst items [1]; |
| unsigned int terminator; |
| } item_lst1; |
| |
| static struct |
| { |
| struct lst items [2]; |
| unsigned int terminator; |
| } item_lst2; |
| |
| /* Checks if logical names are defined for setting system library path and |
| linker program to enable compatibility with earlier VMS versions. */ |
| |
| static void |
| maybe_set_link_compat (void) |
| { |
| char lnm_buff [LNM_C_NAMLENGTH]; |
| unsigned int lnm_buff_len; |
| int status; |
| Descriptor tabledsc, linkdsc; |
| |
| tabledsc.adr = "LNM$JOB"; |
| tabledsc.len = strlen (tabledsc.adr); |
| tabledsc.mbz = 0; |
| |
| linkdsc.adr = "GCC_LD_SYS$LIBRARY"; |
| linkdsc.len = strlen (linkdsc.adr); |
| linkdsc.mbz = 0; |
| |
| item_lst1.items[0].buflen = LNM_C_NAMLENGTH; |
| item_lst1.items[0].item_code = LNM__STRING; |
| item_lst1.items[0].bufaddr = lnm_buff; |
| item_lst1.items[0].retlenaddr = &lnm_buff_len; |
| item_lst1.terminator = 0; |
| |
| status = SYS$TRNLNM |
| (0, /* attr */ |
| &tabledsc, /* tabnam */ |
| &linkdsc, /* lognam */ |
| 0, /* acmode */ |
| &item_lst1); |
| |
| /* If GCC_LD_SYS$LIBRARY is defined, redefine SYS$LIBRARY to search |
| the equivalence name first for system libraries, then the default |
| system library directory */ |
| |
| if ((status & 1) == 1) |
| { |
| unsigned char acmode = PSL_C_USER; /* Don't retain after image exit */ |
| const char *syslib = "SYS$SYSROOT:[SYSLIB]"; /* Default SYS$LIBRARY */ |
| |
| /* Only visible to current and child processes */ |
| tabledsc.adr = "LNM$PROCESS"; |
| tabledsc.len = strlen (tabledsc.adr); |
| tabledsc.mbz = 0; |
| |
| linkdsc.adr = "SYS$LIBRARY"; |
| linkdsc.len = strlen (linkdsc.adr); |
| linkdsc.mbz = 0; |
| |
| item_lst2.items[0].buflen = lnm_buff_len; |
| item_lst2.items[0].item_code = LNM__STRING; |
| item_lst2.items[0].bufaddr = lnm_buff; |
| item_lst2.items[0].retlenaddr = 0; |
| |
| item_lst2.items[1].buflen = strlen (syslib); |
| item_lst2.items[1].item_code = LNM__STRING; |
| item_lst2.items[1].bufaddr = syslib; |
| item_lst2.items[1].retlenaddr = 0; |
| item_lst2.terminator = 0; |
| |
| status = SYS$CRELNM |
| (0, /* attr */ |
| &tabledsc, /* tabnam */ |
| &linkdsc, /* lognam */ |
| &acmode, /* acmode */ |
| &item_lst2); |
| |
| } |
| |
| tabledsc.adr = "LNM$JOB"; |
| tabledsc.len = strlen (tabledsc.adr); |
| tabledsc.mbz = 0; |
| |
| linkdsc.adr = "GCC_LD_LINK"; |
| linkdsc.len = strlen (linkdsc.adr); |
| linkdsc.mbz = 0; |
| |
| item_lst1.items[0].buflen = LNM_C_NAMLENGTH; |
| item_lst1.items[0].item_code = LNM__STRING; |
| item_lst1.items[0].bufaddr = lnm_buff; |
| item_lst1.items[0].retlenaddr = &lnm_buff_len; |
| item_lst1.terminator = 0; |
| |
| status = SYS$TRNLNM |
| (0, /* attr */ |
| &tabledsc, /* tabnam */ |
| &linkdsc, /* lognam */ |
| 0, /* acmode */ |
| &item_lst1); |
| |
| /* If GCC_LD_LINK is defined, redefine LINK to use the equivalence name |
| (sometimes the LINK program version is used by VMS to determine |
| compatibility). */ |
| |
| if ((status & 1) == 1) |
| { |
| unsigned char acmode = PSL_C_USER; /* Don't retain after image exit. */ |
| |
| /* Only visible to current and child processes. */ |
| tabledsc.adr = "LNM$PROCESS"; |
| tabledsc.len = strlen (tabledsc.adr); |
| tabledsc.mbz = 0; |
| |
| linkdsc.adr = "LINK"; |
| linkdsc.len = strlen (linkdsc.adr); |
| linkdsc.mbz = 0; |
| |
| item_lst1.items[0].buflen = lnm_buff_len; |
| item_lst1.items[0].item_code = LNM__STRING; |
| item_lst1.items[0].bufaddr = lnm_buff; |
| item_lst1.items[0].retlenaddr = 0; |
| item_lst1.terminator = 0; |
| |
| status = SYS$CRELNM |
| (0, /* attr */ |
| &tabledsc, /* tabnam */ |
| &linkdsc, /* lognam */ |
| &acmode, /* acmode */ |
| &item_lst1); |
| } |
| } |
| #else |
| static void |
| maybe_set_link_compat (void) |
| { |
| } |
| #endif |
| |
| /* Set environment defined executable attributes. */ |
| |
| static int |
| set_exe (const char *arg) |
| { |
| char allargs [1024]; |
| int res; |
| |
| snprintf (allargs, sizeof (allargs), |
| "$@gnu:[bin]set_exe %s %s", exefullfilename, arg); |
| if (verbose) |
| printf ("%s\n", allargs); |
| |
| res = system (allargs); |
| if (verbose > 1) |
| printf ("$!status = %d\n", res); |
| |
| if ((res & 1) != 1) |
| { |
| fprintf (stderr, "ld error: popen set_exe\n"); |
| return 1; |
| } |
| return 0; |
| } |
| |
| /* The main program. Spawn the VMS linker after fixing up the Unix-like flags |
| and args to be what the VMS linker wants. */ |
| |
| int |
| main (int argc, char **argv) |
| { |
| /* File specification for vms-dwarf2.o. */ |
| char *vmsdwarf2spec = 0; |
| |
| /* File specification for vms-dwarf2eh.o. */ |
| char *vmsdwarf2ehspec = 0; |
| |
| int i; |
| char cwdev[128], *devptr; |
| int cwdevlen; |
| FILE *optfile; |
| char *cwd, *ptr; |
| char *optfilename; |
| int status = 0; |
| |
| /* Some linker options can be set with logicals. */ |
| if (getenv ("GNAT$LD_NOCALL_DEBUG")) |
| ld_nocall_debug = 1; |
| if (getenv ("GNAT$LD_MKTHREADS")) |
| ld_mkthreads = 1; |
| if (getenv ("GNAT$LD_UPCALLS")) |
| ld_upcalls = 1; |
| if (getenv ("GNAT$LD_SHARED_LIBS")) |
| staticp = 0; |
| |
| /* Get current dir. */ |
| #ifdef VMS |
| cwd = getcwd (0, 1024, 1); |
| #else |
| cwd = getcwd (0, 1024); |
| strcat (cwd, "/"); |
| #endif |
| |
| /* Extract device part of the path. */ |
| devptr = strchr (cwd, ':'); |
| if (devptr) |
| cwdevlen = (devptr - cwd) + 1; |
| else |
| cwdevlen = 0; |
| memcpy (cwdev, cwd, cwdevlen); |
| cwdev [cwdevlen] = '\0'; |
| |
| maybe_set_link_compat (); |
| |
| /* Linker command starts with the command name. */ |
| addarg ("$ link"); |
| |
| /* Pass to find args that have to be append first. */ |
| preprocess_args (argc , argv); |
| |
| /* Pass to find the rest of the args. */ |
| process_args (argc , argv); |
| |
| if (!verbose) |
| addarg ("/noinform"); |
| |
| /* Create a temp file to hold args, otherwise we can easily exceed the VMS |
| command line length limits. */ |
| optfilename = (char *) xmalloc (strlen (exefilename) + 13); |
| strcpy (optfilename, exefilename); |
| ptr = strrchr (optfilename, '.'); |
| if (ptr) |
| *ptr = 0; |
| strcat (optfilename, ".opt_tmpfile"); |
| optfile = fopen (optfilename, "w"); |
| |
| /* Write out the IDENTIFICATION argument first so that it can be overridden |
| by an options file. */ |
| for (i = 1; i < argc; i++) |
| { |
| int arg_len = strlen (argv[i]); |
| |
| if (arg_len > 6 && strncasecmp (argv[i], "IDENT=", 6) == 0) |
| { |
| /* Comes from command line. If present will always appear before |
| --identification=... and will override. */ |
| break; |
| } |
| else if (arg_len > 17 |
| && strncasecmp (argv[i], "--identification=", 17) == 0) |
| { |
| /* Comes from pragma Ident (). */ |
| fprintf (optfile, "case_sensitive=yes\n"); |
| fprintf (optfile, "IDENTIFICATION=\"%-.15s\"\n", &argv[i][17]); |
| fprintf (optfile, "case_sensitive=NO\n"); |
| } |
| } |
| |
| for (i = 1; i < argc; i++) |
| { |
| int arg_len = strlen (argv[i]); |
| |
| if (strcmp (argv[i], "-o") == 0) |
| { |
| /* Already handled. */ |
| i++; |
| } |
| else if (arg_len > 2 && strncmp (argv[i], "-l", 2) == 0) |
| { |
| const char *libname; |
| |
| libname = expand_lib (&argv[i][2]); |
| if (libname != NULL) |
| { |
| int len = strlen (libname); |
| const char *ext; |
| |
| if (len > 4 && strcasecmp (&libname [len-4], ".exe") == 0) |
| ext = "/shareable"; |
| else |
| ext = "/library"; |
| |
| if (libname[0] == '[') |
| fprintf (optfile, "%s%s%s\n", cwdev, libname, ext); |
| else |
| fprintf (optfile, "%s%s\n", libname, ext); |
| } |
| } |
| else if (strcmp (argv[i], "-v" ) == 0 |
| || strncmp (argv[i], "-g", 2 ) == 0 |
| || strcmp (argv[i], "-static" ) == 0 |
| || strcmp (argv[i], "-map" ) == 0 |
| || strcmp (argv[i], "-save-temps") == 0 |
| || strcmp (argv[i], "--noinhibit-exec") == 0 |
| || (arg_len > 2 && strncmp (argv[i], "-L", 2) == 0) |
| || (arg_len >= 6 && strncmp (argv[i], "-share", 6) == 0)) |
| { |
| /* Already handled. */ |
| } |
| else if (strncmp (argv[i], "--opt=", 6) == 0) |
| fprintf (optfile, "%s\n", argv[i] + 6); |
| else if (arg_len > 1 && argv[i][0] == '@') |
| { |
| /* Read response file (in fact a single line of filenames). */ |
| FILE *atfile; |
| char *ptr, *ptr1; |
| struct stat statbuf; |
| char *buff; |
| int len; |
| |
| if (stat (&argv[i][1], &statbuf)) |
| { |
| fprintf (stderr, "Couldn't open linker response file: %s\n", |
| &argv[i][1]); |
| exit (EXIT_FAILURE); |
| } |
| |
| /* Read the line. */ |
| buff = (char *) xmalloc (statbuf.st_size + 1); |
| atfile = fopen (&argv[i][1], "r"); |
| fgets (buff, statbuf.st_size + 1, atfile); |
| fclose (atfile); |
| |
| /* Remove trailing \n. */ |
| len = strlen (buff); |
| if (buff [len - 1] == '\n') |
| { |
| buff [len - 1] = 0; |
| len--; |
| } |
| |
| /* Put the filenames to the opt file. */ |
| ptr = buff; |
| do |
| { |
| ptr1 = strchr (ptr, ' '); |
| if (ptr1) |
| *ptr1 = 0; |
| |
| /* Add device name if a path is present. */ |
| ptr = to_host_file_spec (ptr); |
| if (ptr[0] == '[') |
| fprintf (optfile, "%s%s\n", cwdev, ptr); |
| else |
| fprintf (optfile, "%s\n", ptr); |
| |
| ptr = ptr1 + 1; |
| } |
| while (ptr1); |
| } |
| else if ((argv[i][0] == '/') && (strchr (&argv[i][1], '/') == 0)) |
| { |
| /* Unix style file specs and VMS style switches look alike, |
| so assume an arg consisting of one and only one slash, |
| and that being first, is really a switch. */ |
| addarg (argv[i]); |
| } |
| else if (arg_len > 4 |
| && strncasecmp (&argv[i][arg_len-4], ".opt", 4) == 0) |
| { |
| /* Read option file. */ |
| FILE *optfile1; |
| char buff[256]; |
| |
| /* Disable __UNIX_FOPEN redefinition in case user supplied .opt |
| file is not stream oriented. */ |
| |
| optfile1 = (fopen) (argv[i], "r"); |
| if (optfile1 == 0) |
| { |
| perror (argv[i]); |
| status = 1; |
| goto cleanup_and_exit; |
| } |
| |
| while (fgets (buff, sizeof (buff), optfile1)) |
| fputs (buff, optfile); |
| |
| fclose (optfile1); |
| } |
| else if (arg_len > 7 && strncasecmp (argv[i], "GSMATCH", 7) == 0) |
| fprintf (optfile, "%s\n", argv[i]); |
| else if (arg_len > 6 && strncasecmp (argv[i], "IDENT=", 6) == 0) |
| { |
| /* Comes from command line and will override pragma. */ |
| fprintf (optfile, "case_sensitive=yes\n"); |
| fprintf (optfile, "IDENT=\"%15.15s\"\n", &argv[i][6]); |
| fprintf (optfile, "case_sensitive=NO\n"); |
| } |
| else if (arg_len > 17 |
| && strncasecmp (argv[i], "--identification=", 17) == 0) |
| { |
| /* Already handled. */ |
| } |
| else |
| { |
| /* Assume filename arg. */ |
| const char *file; |
| const char *addswitch = NULL; |
| char *buff; |
| int buff_len; |
| int is_cld = 0; |
| |
| file = to_host_file_spec (argv[i]); |
| arg_len = strlen (file); |
| |
| /* Handle shareable image libraries. */ |
| if (arg_len > 4 && strcasecmp (&file[arg_len - 4], ".exe") == 0) |
| addswitch = "/shareable"; |
| else if (arg_len > 4 && strcasecmp (&file[arg_len - 4], ".cld") == 0) |
| { |
| addswitch = "/shareable"; |
| is_cld = 1; |
| } |
| |
| /* Handle object libraries. */ |
| else if (arg_len > 2 && strcasecmp (&file[arg_len - 2], ".a") == 0) |
| addswitch = "/lib"; |
| else if (arg_len > 4 && strcasecmp (&file[arg_len - 4], ".olb") == 0) |
| addswitch = "/lib"; |
| |
| /* Absolutize file location. */ |
| if (file[0] == '[') |
| { |
| buff = (char *) xmalloc (cwdevlen + arg_len + 1); |
| sprintf (buff, "%s%s", cwdev, file); |
| } |
| else if (strchr (file, ':')) |
| { |
| buff = xstrdup (file); |
| } |
| else |
| { |
| buff = (char *) xmalloc (strlen (cwd) + arg_len + 1); |
| sprintf (buff, "%s%s", cwd, file); |
| } |
| |
| buff_len = strlen (buff); |
| |
| if (buff_len >= 15 |
| && strcasecmp (&buff[buff_len - 14], "vms-dwarf2eh.o") == 0) |
| { |
| /* Remind of it. */ |
| vmsdwarf2ehspec = xstrdup (buff); |
| } |
| else if (buff_len >= 13 |
| && strcasecmp (&buff[buff_len - 12], "vms-dwarf2.o") == 0) |
| { |
| /* Remind of it. */ |
| vmsdwarf2spec = xstrdup (buff); |
| } |
| else if (is_cld) |
| { |
| /* Command line definition file. */ |
| addarg (buff); |
| addarg (addswitch); |
| addarg (","); |
| } |
| else |
| { |
| fprintf (optfile, "%s%s\n", |
| buff, addswitch != NULL ? addswitch : ""); |
| } |
| free (buff); |
| } |
| } |
| |
| if (vmsdwarf2ehspec) |
| { |
| /* Sequentialize exception handling info. */ |
| |
| fprintf (optfile, "case_sensitive=yes\n"); |
| fprintf (optfile, "cluster=DWARF2eh,,,%s\n", vmsdwarf2ehspec); |
| fprintf (optfile, "collect=DWARF2eh,eh_frame\n"); |
| fprintf (optfile, "case_sensitive=NO\n"); |
| } |
| |
| if (debug && vmsdwarf2spec) |
| { |
| /* Sequentialize the debug info. */ |
| |
| fprintf (optfile, "case_sensitive=yes\n"); |
| fprintf (optfile, "cluster=DWARF2debug,,,%s\n", vmsdwarf2spec); |
| fprintf (optfile, "collect=DWARF2debug,debug_abbrev,debug_aranges,-\n"); |
| fprintf (optfile, " debug_frame,debug_info,debug_line,debug_loc,-\n"); |
| fprintf (optfile, " debug_macinfo,debug_pubnames,debug_str,-\n"); |
| fprintf (optfile, " debug_zzzzzz\n"); |
| fprintf (optfile, "case_sensitive=NO\n"); |
| } |
| |
| if (debug && share && vmsdwarf2spec) |
| { |
| /* Sequentialize the shared library debug info. */ |
| |
| fprintf (optfile, "case_sensitive=yes\n"); |
| fprintf (optfile, "symbol_vector=(-\n"); |
| fprintf (optfile, |
| "%s$DWARF2.DEBUG_ABBREV/$dwarf2.debug_abbrev=DATA,-\n", |
| sharebasename); |
| fprintf (optfile, |
| "%s$DWARF2.DEBUG_ARANGES/$dwarf2.debug_aranges=DATA,-\n", |
| sharebasename); |
| fprintf (optfile, "%s$DWARF2.DEBUG_FRAME/$dwarf2.debug_frame=DATA,-\n", |
| sharebasename); |
| fprintf (optfile, "%s$DWARF2.DEBUG_INFO/$dwarf2.debug_info=DATA,-\n", |
| sharebasename); |
| fprintf (optfile, "%s$DWARF2.DEBUG_LINE/$dwarf2.debug_line=DATA,-\n", |
| sharebasename); |
| fprintf (optfile, "%s$DWARF2.DEBUG_LOC/$dwarf2.debug_loc=DATA,-\n", |
| sharebasename); |
| fprintf (optfile, |
| "%s$DWARF2.DEBUG_MACINFO/$dwarf2.debug_macinfo=DATA,-\n", |
| sharebasename); |
| fprintf (optfile, |
| "%s$DWARF2.DEBUG_PUBNAMES/$dwarf2.debug_pubnames=DATA,-\n", |
| sharebasename); |
| fprintf (optfile, "%s$DWARF2.DEBUG_STR/$dwarf2.debug_str=DATA,-\n", |
| sharebasename); |
| fprintf (optfile, "%s$DWARF2.DEBUG_ZZZZZZ/$dwarf2.debug_zzzzzz=DATA)\n", |
| sharebasename); |
| fprintf (optfile, "case_sensitive=NO\n"); |
| } |
| |
| fprintf (optfile, "PSECT_ATTR=LIB$INITIALIZE,GBL\n"); |
| fclose (optfile); |
| |
| /* Append opt file. */ |
| addarg (" "); |
| addarg (optfilename); |
| addarg ("/opt"); |
| |
| if (verbose) |
| printf ("%s\n", link_cmd); |
| |
| status = system (link_cmd); |
| if (verbose > 1) |
| printf ("$!status = %d\n", status); |
| |
| if ((status & 1) != 1) |
| { |
| status = 1; |
| goto cleanup_and_exit; |
| } |
| |
| if (debug && !share && ld_nocall_debug) |
| { |
| status = set_exe ("/flags=nocall_debug"); |
| if (status != 0) |
| goto cleanup_and_exit; |
| } |
| |
| if (!share && ld_mkthreads) |
| { |
| status = set_exe ("/flags=mkthreads"); |
| if (status != 0) |
| goto cleanup_and_exit; |
| } |
| |
| if (!share && ld_upcalls) |
| { |
| status = set_exe ("/flags=upcalls"); |
| if (status != 0) |
| goto cleanup_and_exit; |
| } |
| |
| status = 0; |
| |
| cleanup_and_exit: |
| if (!save_temps) |
| remove (optfilename); |
| |
| if (status == 0) |
| exit (EXIT_SUCCESS); |
| |
| if (exefullfilename && inhibit_exec == 1) |
| remove (exefullfilename); |
| |
| exit (EXIT_FAILURE); |
| } |