1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
24 */
25
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <unistd.h>
29 #include <stdarg.h>
30 #include <string.h>
31 #include <strings.h>
32 #include <errno.h>
33 #include <fcntl.h>
34 #include <libintl.h>
35 #include <locale.h>
36 #include <fcntl.h>
37 #include <ar.h>
38 #include <gelf.h>
39 #include "conv.h"
40 #include "libld.h"
41 #include "machdep.h"
42 #include "msg.h"
43
44 /*
45 * The following prevent us from having to include ctype.h which defines these
46 * functions as macros which reference the __ctype[] array. Go through .plt's
47 * to get to these functions in libc rather than have every invocation of ld
48 * have to suffer the R_SPARC_COPY overhead of the __ctype[] array.
49 */
50 extern int isspace(int);
51
52 /*
53 * We examine ELF objects, and archives containing ELF objects, in order
54 * to determine the ELFCLASS of the resulting object and/or the linker to be
55 * used. We want to avoid the overhead of libelf for this, at least until
56 * we are certain that we need it, so we start by reading bytes from
57 * the beginning of the file. This type defines the buffer used to read
58 * these initial bytes.
59 *
60 * A plain ELF object will start with an ELF header, whereas an archive
61 * starts with a magic string (ARMAG) that is SARMAG bytes long. Any valid
62 * ELF file or archive will contain more bytes than this buffer, so any
63 * file shorter than this can be safely assummed not to be of interest.
64 *
65 * The ELF header for ELFCLASS32 and ELFCLASS64 are identical up through the
66 * the e_version field, and all the information we require is found in this
67 * common prefix. Furthermore, this cannot change, as the layout of an ELF
68 * header is fixed by the ELF ABI. Hence, the ehdr part of this union is
69 * not a full ELF header, but only the class-independent prefix that we need.
70 *
71 * As this is a raw (non-libelf) read, we are responsible for handling any
72 * byte order difference between the object and the system running this
73 * program when we read any datum larger than a byte (i.e. e_machine) from
74 * this header.
75 */
76 typedef union {
77 struct { /* Must match start of ELFxx_Ehdr in <sys/elf.h> */
78 uchar_t e_ident[EI_NIDENT]; /* ident bytes */
79 Half e_type; /* file type */
80 Half e_machine; /* target machine */
81 } ehdr;
82 char armag[SARMAG];
83 } FILE_HDR;
84
85
86 /*
87 * Print a message to stdout
88 */
89 void
veprintf(Lm_list * lml,Error error,const char * format,va_list args)90 veprintf(Lm_list *lml, Error error, const char *format, va_list args)
91 {
92 static const char *strings[ERR_NUM];
93
94 #if defined(lint)
95 /*
96 * The lml argument is only meaningful for diagnostics sent to ld.so.1.
97 * Supress the lint error by making a dummy assignment.
98 */
99 lml = 0;
100 #endif
101 /*
102 * For error types we issue a prefix for, make sure the necessary
103 * string has been internationalized and is ready.
104 */
105 switch (error) {
106 case ERR_WARNING_NF:
107 if (strings[ERR_WARNING_NF] == NULL)
108 strings[ERR_WARNING_NF] = MSG_INTL(MSG_ERR_WARNING);
109 break;
110 case ERR_WARNING:
111 if (strings[ERR_WARNING] == NULL)
112 strings[ERR_WARNING] = MSG_INTL(MSG_ERR_WARNING);
113 break;
114 case ERR_GUIDANCE:
115 if (strings[ERR_GUIDANCE] == NULL)
116 strings[ERR_GUIDANCE] = MSG_INTL(MSG_ERR_GUIDANCE);
117 break;
118 case ERR_FATAL:
119 if (strings[ERR_FATAL] == NULL)
120 strings[ERR_FATAL] = MSG_INTL(MSG_ERR_FATAL);
121 break;
122 case ERR_ELF:
123 if (strings[ERR_ELF] == NULL)
124 strings[ERR_ELF] = MSG_INTL(MSG_ERR_ELF);
125 }
126
127 /* If strings[] element for our error type is non-NULL, issue prefix */
128 if (strings[error] != NULL) {
129 (void) fputs(MSG_ORIG(MSG_STR_LDDIAG), stderr);
130 (void) fputs(strings[error], stderr);
131 }
132
133 (void) vfprintf(stderr, format, args);
134 if (error == ERR_ELF) {
135 int elferr;
136
137 if ((elferr = elf_errno()) != 0)
138 (void) fprintf(stderr, MSG_ORIG(MSG_STR_ELFDIAG),
139 elf_errmsg(elferr));
140 }
141 (void) fprintf(stderr, MSG_ORIG(MSG_STR_NL));
142 (void) fflush(stderr);
143 }
144
145
146 /*
147 * Print a message to stdout
148 */
149 /* VARARGS3 */
150 void
eprintf(Lm_list * lml,Error error,const char * format,...)151 eprintf(Lm_list *lml, Error error, const char *format, ...)
152 {
153 va_list args;
154
155 va_start(args, format);
156 veprintf(lml, error, format, args);
157 va_end(args);
158 }
159
160
161 /*
162 * Examine the first object in an archive to determine its ELFCLASS
163 * and machine type.
164 *
165 * entry:
166 * fd - Open file descriptor for file
167 * elf - libelf ELF descriptor
168 * class_ret, mach_ret - Address of variables to receive ELFCLASS
169 * and machine type.
170 *
171 * exit:
172 * On success, *class_ret and *mach_ret are filled in, and True (1)
173 * is returned. On failure, False (0) is returned.
174 */
175 static int
archive(int fd,Elf * elf,uchar_t * class_ret,Half * mach_ret)176 archive(int fd, Elf *elf, uchar_t *class_ret, Half *mach_ret)
177 {
178 Elf_Cmd cmd = ELF_C_READ;
179 Elf_Arhdr *arhdr;
180 Elf *_elf = NULL;
181 int found = 0;
182
183 /*
184 * Process each item within the archive until we find the first
185 * ELF object, or alternatively another archive to recurse into.
186 * Stop after analyzing the first plain object found.
187 */
188 while (!found && ((_elf = elf_begin(fd, cmd, elf)) != NULL)) {
189 if ((arhdr = elf_getarhdr(_elf)) == NULL)
190 return (0);
191 if (*arhdr->ar_name != '/') {
192 switch (elf_kind(_elf)) {
193 case ELF_K_AR:
194 found = archive(fd, _elf, class_ret, mach_ret);
195 break;
196 case ELF_K_ELF:
197 if (gelf_getclass(_elf) == ELFCLASS64) {
198 Elf64_Ehdr *ehdr;
199
200 if ((ehdr = elf64_getehdr(_elf)) ==
201 NULL)
202 break;
203 *class_ret = ehdr->e_ident[EI_CLASS];
204 *mach_ret = ehdr->e_machine;
205 } else {
206 Elf32_Ehdr *ehdr;
207
208 if ((ehdr = elf32_getehdr(_elf)) ==
209 NULL)
210 break;
211 *class_ret = ehdr->e_ident[EI_CLASS];
212 *mach_ret = ehdr->e_machine;
213 }
214 found = 1;
215 break;
216 }
217 }
218
219 cmd = elf_next(_elf);
220 (void) elf_end(_elf);
221 }
222
223 return (found);
224 }
225
226 /*
227 * Determine:
228 * - ELFCLASS of resulting object (class)
229 * - Whether user specified class of the linker (ldclass)
230 * - ELF machine type of resulting object (m_mach)
231 *
232 * In order of priority, we determine this information as follows:
233 *
234 * - Command line options (-32, -64, -z altexec64, -z target).
235 * - From the first plain object seen on the command line. (This is
236 * by far the most common case.)
237 * - From the first object contained within the first archive
238 * on the command line.
239 * - If all else fails, we assume a 32-bit object for the native machine.
240 *
241 * entry:
242 * argc, argv - Command line argument vector
243 * class_ret - Address of variable to receive ELFCLASS of output object
244 * ldclass_ret - Address of variable to receive ELFCLASS of
245 * linker to use. This will be ELFCLASS32/ELFCLASS64 if one
246 * is explicitly specified, and ELFCLASSNONE otherwise.
247 * ELFCLASSNONE therefore means that we should use the best
248 * link-editor that the system/kernel will allow.
249 */
250 static int
process_args(int argc,char ** argv,uchar_t * class_ret,uchar_t * ldclass_ret,Half * mach)251 process_args(int argc, char **argv, uchar_t *class_ret, uchar_t *ldclass_ret,
252 Half *mach)
253 {
254 uchar_t ldclass = ELFCLASSNONE, class = ELFCLASSNONE, ar_class;
255 Half mach32 = EM_NONE, mach64 = EM_NONE, ar_mach;
256 int c, ar_found = 0;
257
258 /*
259 * In general, libld.so is responsible for processing the
260 * command line options. The exception to this are those options
261 * that contain information about which linker to run and the
262 * class/machine of the output object. We examine the options
263 * here looking for the following:
264 *
265 * -32 Produce an ELFCLASS32 object. This is the default, so
266 * -32 is only needed when linking entirely from archives,
267 * and the first archive contains a mix of 32 and 64-bit
268 * objects, and the first object in that archive is 64-bit.
269 * We do not expect this option to get much use, but it
270 * ensures that the user can handle any situation.
271 *
272 * -64 Produce an ELFCLASS64 object. (Note that this will
273 * indirectly cause the use of the 64-bit linker if
274 * the system is 64-bit capable). The most common need
275 * for this option is when linking a filter object entirely
276 * from a mapfile. The less common case is when linking
277 * entirely from archives, and the first archive contains
278 * a mix of 32 and 64-bit objects, and the first object
279 * in that archive is 32-bit.
280 *
281 * -z altexec64
282 * Use the 64-bit linker regardless of the class
283 * of the output object.
284 *
285 * -z target=platform
286 * Produce output object for the specified platform.
287 * This option is needed when producing an object
288 * for a non-native target entirely from a mapfile,
289 * or when linking entirely from an archive containing
290 * objects for multiple targets, and the first object
291 * in the archive is not for the desired target.
292 *
293 * If we've already processed an object and we find -32/-64, and
294 * the object is of the wrong class, we have an error condition.
295 * We ignore it here, and let it fall through to libld, where the
296 * proper diagnosis and error message will occur.
297 */
298 opterr = 0;
299 optind = 1;
300 getmore:
301 while ((c = ld_getopt(0, optind, argc, argv)) != -1) {
302 switch (c) {
303 case '3':
304 if (strncmp(optarg, MSG_ORIG(MSG_ARG_TWO),
305 MSG_ARG_TWO_SIZE) == 0)
306 class = ELFCLASS32;
307 break;
308
309 case '6':
310 if (strncmp(optarg, MSG_ORIG(MSG_ARG_FOUR),
311 MSG_ARG_FOUR_SIZE) == 0)
312 class = ELFCLASS64;
313 break;
314
315 case 'z':
316 #if !defined(_LP64)
317 /* -z altexec64 */
318 if (strncmp(optarg, MSG_ORIG(MSG_ARG_ALTEXEC64),
319 MSG_ARG_ALTEXEC64_SIZE) == 0) {
320 ldclass = ELFCLASS64;
321 break;
322 }
323 #endif
324 /* -z target=platform */
325 if (strncmp(optarg, MSG_ORIG(MSG_ARG_TARGET),
326 MSG_ARG_TARGET_SIZE) == 0) {
327 char *pstr = optarg + MSG_ARG_TARGET_SIZE;
328
329 if (strcasecmp(pstr,
330 MSG_ORIG(MSG_TARG_SPARC)) == 0) {
331 mach32 = EM_SPARC;
332 mach64 = EM_SPARCV9;
333 } else if (strcasecmp(pstr,
334 MSG_ORIG(MSG_TARG_X86)) == 0) {
335 mach32 = EM_386;
336 mach64 = EM_AMD64;
337 } else {
338 eprintf(0, ERR_FATAL,
339 MSG_INTL(MSG_ERR_BADTARG), pstr);
340 return (1);
341 }
342 }
343 break;
344 }
345 }
346
347 /*
348 * Continue to look for the first ELF object to determine the class of
349 * objects to operate on. At the same time, look for the first archive
350 * of ELF objects --- if no plain ELF object is specified, the type
351 * of the first ELF object in the first archive will be used. If
352 * there is no object, and no archive, then we fall back to a 32-bit
353 * object for the native machine.
354 */
355 for (; optind < argc; optind++) {
356 int fd;
357 FILE_HDR hdr;
358
359 /*
360 * If we detect some more options return to getopt().
361 * Checking argv[optind][1] against null prevents a forever
362 * loop if an unadorned `-' argument is passed to us.
363 */
364 if (argv[optind][0] == '-') {
365 if (argv[optind][1] == '\0')
366 continue;
367 else
368 goto getmore;
369 }
370
371 /*
372 * If we've already determined the object class and
373 * machine type, continue to the next argument. Only
374 * the first object contributes to this decision, and
375 * there's no value to opening or examing the subsequent
376 * ones. We do need to keep going though, because there
377 * may be additional options that might affect our
378 * class/machine decision.
379 */
380 if ((class != ELFCLASSNONE) && (mach32 != EM_NONE))
381 continue;
382
383 /*
384 * Open the file and determine if it is an object. We are
385 * looking for ELF objects, or archives of ELF objects.
386 *
387 * Plain objects are simple, and are the common case, so
388 * we examine them directly and avoid the map-unmap-map
389 * that would occur if we used libelf. Archives are too
390 * complex to be worth accessing directly, so if we identify
391 * an archive, we use libelf on it and accept the cost.
392 */
393 if ((fd = open(argv[optind], O_RDONLY)) == -1) {
394 int err = errno;
395
396 eprintf(0, ERR_FATAL, MSG_INTL(MSG_SYS_OPEN),
397 argv[optind], strerror(err));
398 return (1);
399 }
400
401 if (pread(fd, &hdr, sizeof (hdr), 0) != sizeof (hdr)) {
402 (void) close(fd);
403 continue;
404 }
405
406 if ((hdr.ehdr.e_ident[EI_MAG0] == ELFMAG0) &&
407 (hdr.ehdr.e_ident[EI_MAG1] == ELFMAG1) &&
408 (hdr.ehdr.e_ident[EI_MAG2] == ELFMAG2) &&
409 (hdr.ehdr.e_ident[EI_MAG3] == ELFMAG3)) {
410 if (class == ELFCLASSNONE) {
411 class = hdr.ehdr.e_ident[EI_CLASS];
412 if ((class != ELFCLASS32) &&
413 (class != ELFCLASS64))
414 class = ELFCLASSNONE;
415 }
416
417 if (mach32 == EM_NONE) {
418 int one = 1;
419 uchar_t *one_p = (uchar_t *)&one;
420 int ld_elfdata;
421
422 ld_elfdata = (one_p[0] == 1) ?
423 ELFDATA2LSB : ELFDATA2MSB;
424 /*
425 * Both the 32 and 64-bit versions get the
426 * type from the object. If the user has
427 * asked for an inconsistant class/machine
428 * combination, libld will catch it.
429 */
430 mach32 = mach64 =
431 (ld_elfdata == hdr.ehdr.e_ident[EI_DATA]) ?
432 hdr.ehdr.e_machine :
433 BSWAP_HALF(hdr.ehdr.e_machine);
434 }
435 } else if (!ar_found &&
436 (memcmp(&hdr.armag, ARMAG, SARMAG) == 0)) {
437 Elf *elf;
438
439 (void) elf_version(EV_CURRENT);
440 if ((elf = elf_begin(fd, ELF_C_READ, NULL)) == NULL) {
441 (void) close(fd);
442 continue;
443 }
444 if (elf_kind(elf) == ELF_K_AR)
445 ar_found =
446 archive(fd, elf, &ar_class, &ar_mach);
447 (void) elf_end(elf);
448 }
449
450 (void) close(fd);
451 }
452
453 /*
454 * ELFCLASS of output object: If we did not establish a class from a
455 * command option, or from the first plain object, then use the class
456 * from the first archive, and failing that, default to 32-bit.
457 */
458 if (class == ELFCLASSNONE)
459 class = ar_found ? ar_class : ELFCLASS32;
460 *class_ret = class;
461
462 /* ELFCLASS of link-editor to use */
463 *ldclass_ret = ldclass;
464
465 /*
466 * Machine type of output object: If we did not establish a machine
467 * type from the command line, or from the first plain object, then
468 * use the machine established by the first archive, and failing that,
469 * use the native machine.
470 */
471 *mach = (class == ELFCLASS64) ? mach64 : mach32;
472 if (*mach == EM_NONE)
473 if (ar_found)
474 *mach = ar_mach;
475 else
476 *mach = (class == ELFCLASS64) ? M_MACH_64 : M_MACH_32;
477
478 return (0);
479 }
480
481 /*
482 * Process an LD_OPTIONS environment string. This routine is first called to
483 * count the number of options, and second to initialize a new argument array
484 * with each option.
485 */
486 static int
process_ldoptions(char * str,char ** nargv)487 process_ldoptions(char *str, char **nargv)
488 {
489 int argc = 0;
490 char *arg = str;
491
492 /*
493 * Walk the environment string processing any arguments that are
494 * separated by white space.
495 */
496 while (*str != '\0') {
497 if (isspace(*str)) {
498 /*
499 * If a new argument array has been provided, terminate
500 * the original environment string, and initialize the
501 * appropriate argument array entry.
502 */
503 if (nargv) {
504 *str++ = '\0';
505 nargv[argc] = arg;
506 }
507
508 argc++;
509 while (isspace(*str))
510 str++;
511 arg = str;
512 } else
513 str++;
514 }
515 if (arg != str) {
516 /*
517 * If a new argument array has been provided, initialize the
518 * final argument array entry.
519 */
520 if (nargv)
521 nargv[argc] = arg;
522 argc++;
523 }
524
525 return (argc);
526 }
527
528 /*
529 * Determine whether an LD_OPTIONS environment variable is set, and if so,
530 * prepend environment string as a series of options to the argv array.
531 */
532 static int
prepend_ldoptions(int * argcp,char *** argvp)533 prepend_ldoptions(int *argcp, char ***argvp)
534 {
535 int nargc;
536 char **nargv, *ld_options;
537 int err, count;
538
539 if ((ld_options = getenv(MSG_ORIG(MSG_LD_OPTIONS))) == NULL)
540 return (0);
541
542 /*
543 * Get rid of any leading white space, and make sure the environment
544 * string has size.
545 */
546 while (isspace(*ld_options))
547 ld_options++;
548 if (ld_options[0] == '\0')
549 return (0);
550
551 /*
552 * Prevent modification of actual environment strings.
553 */
554 if ((ld_options = strdup(ld_options)) == NULL) {
555 err = errno;
556 eprintf(0, ERR_FATAL, MSG_INTL(MSG_SYS_ALLOC), strerror(err));
557 return (1);
558 }
559
560 /*
561 * Determine the number of options provided.
562 */
563 nargc = process_ldoptions(ld_options, NULL);
564
565 /*
566 * Allocate a new argv array big enough to hold the new options from
567 * the environment string and the old argv options.
568 */
569 if ((nargv = malloc((nargc + *argcp + 1) * sizeof (char *))) == NULL) {
570 err = errno;
571 eprintf(0, ERR_FATAL, MSG_INTL(MSG_SYS_ALLOC), strerror(err));
572 return (1);
573 }
574
575 /*
576 * Initialize first element of new argv array to be the first element
577 * of the old argv array (ie. calling programs name). Then add the new
578 * args obtained from the environment.
579 */
580 nargc = 0;
581 nargv[nargc++] = (*argvp)[0];
582 nargc += process_ldoptions(ld_options, &nargv[nargc]);
583
584 /*
585 * Now add the original argv array (skipping argv[0]) to the end of the
586 * new argv array, and re-vector argc and argv to reference this new
587 * array
588 */
589 for (count = 1; count < *argcp; count++, nargc++)
590 nargv[nargc] = (*argvp)[count];
591
592 nargv[nargc] = NULL;
593
594 *argcp = nargc;
595 *argvp = nargv;
596
597 return (0);
598 }
599
600 /*
601 * Check to see if there is a LD_ALTEXEC=<path to alternate ld> in the
602 * environment. If so, first null the environment variable out, and then
603 * exec() the binary pointed to by the environment variable, passing the same
604 * arguments as the originating process. This mechanism permits using
605 * alternate link-editors (debugging/developer copies) even in complex build
606 * environments.
607 */
608 static int
ld_altexec(char ** argv,char ** envp)609 ld_altexec(char **argv, char **envp)
610 {
611 char *execstr;
612 char **str;
613 int err;
614
615 for (str = envp; *str; str++) {
616 if (strncmp(*str, MSG_ORIG(MSG_LD_ALTEXEC),
617 MSG_LD_ALTEXEC_SIZE) == 0) {
618 break;
619 }
620 }
621
622 /*
623 * If LD_ALTEXEC isn't set, return to continue executing the present
624 * link-editor.
625 */
626 if (*str == 0)
627 return (0);
628
629 /*
630 * Get a pointer to the actual string. If it's a null entry, return.
631 */
632 execstr = strdup(*str + MSG_LD_ALTEXEC_SIZE);
633 if (*execstr == '\0')
634 return (0);
635
636 /*
637 * Null out the LD_ALTEXEC= environment entry.
638 */
639 (*str)[MSG_LD_ALTEXEC_SIZE] = '\0';
640
641 /*
642 * Set argv[0] to point to our new linker
643 */
644 argv[0] = execstr;
645
646 /*
647 * And attempt to execute it.
648 */
649 (void) execve(execstr, argv, envp);
650
651 /*
652 * If the exec() fails, return a failure indication.
653 */
654 err = errno;
655 eprintf(0, ERR_FATAL, MSG_INTL(MSG_SYS_EXEC), execstr,
656 strerror(err));
657 return (1);
658 }
659
660 int
main(int argc,char ** argv,char ** envp)661 main(int argc, char **argv, char **envp)
662 {
663 char **oargv = argv;
664 uchar_t class, ldclass, checkclass;
665 Half mach;
666
667 /*
668 * Establish locale.
669 */
670 (void) setlocale(LC_MESSAGES, MSG_ORIG(MSG_STR_EMPTY));
671 (void) textdomain(MSG_ORIG(MSG_SUNW_OST_SGS));
672
673 /*
674 * Execute an alternate linker if the LD_ALTEXEC environment variable is
675 * set. If a specified alternative could not be found, bail.
676 */
677 if (ld_altexec(argv, envp))
678 return (1);
679
680 /*
681 * Check the LD_OPTIONS environment variable, and if present prepend
682 * the arguments specified to the command line argument list.
683 */
684 if (prepend_ldoptions(&argc, &argv))
685 return (1);
686
687 /*
688 * Examine the command arguments to determine:
689 * - object class
690 * - link-editor class
691 * - target machine
692 */
693 if (process_args(argc, argv, &class, &ldclass, &mach))
694 return (1);
695
696 /*
697 * Unless a 32-bit link-editor was explicitly requested, try
698 * to exec the 64-bit version.
699 */
700 if (ldclass != ELFCLASS32)
701 checkclass = conv_check_native(oargv, envp);
702
703 /*
704 * If an attempt to exec the 64-bit link-editor fails:
705 * - Bail if the 64-bit linker was explicitly requested
706 * - Continue quietly if the 64-bit linker was not requested.
707 * This is undoubtedly due to hardware/kernel limitations,
708 * and therefore represents the best we can do. Note that
709 * the 32-bit linker is capable of linking anything the
710 * 64-bit version is, subject to a 4GB limit on memory, and
711 * 2GB object size.
712 */
713 if ((ldclass == ELFCLASS64) && (checkclass != ELFCLASS64)) {
714 eprintf(0, ERR_FATAL, MSG_INTL(MSG_SYS_64));
715 return (1);
716 }
717
718 /* Call the libld entry point for the specified ELFCLASS */
719 if (class == ELFCLASS64)
720 return (ld64_main(argc, argv, mach));
721 else
722 return (ld32_main(argc, argv, mach));
723 }
724
725 /*
726 * We supply this function for the msg module
727 */
728 const char *
_ld_msg(Msg mid)729 _ld_msg(Msg mid)
730 {
731 return (gettext(MSG_ORIG(mid)));
732 }
733