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) 1988 AT&T
  24  *        All Rights Reserved
  25  *
  26  * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
  27  */
  28 /*
  29  * Copyright (c) 2012, Joyent, Inc.  All rights reserved.
  30  */
  31 
  32 /*
  33  * Publicly available flags are defined in ld(1).   The following flags are
  34  * private, and may be removed at any time.
  35  *
  36  *    OPTION                    MEANING
  37  *
  38  *    -z dtrace=symbol          assigns symbol to PT_SUNWDTRACE segment,
  39  *                              providing scratch area for dtrace processing.
  40  *
  41  *    -z noreloc                suppress relocation processing.  This provides
  42  *                              a mechanism for validating kernel module symbol
  43  *                              resolution that would normally incur fatal
  44  *                              relocation errors.
  45  *
  46  *    -z rtldinfo=symbol        assigns symbol to SUNW_RTLDINF dynamic tag,
  47  *                              providing pre-initialization specific routines
  48  *                              for TLS initialization.
  49  *
  50  *    -z nointerp               suppress the addition of an interpreter
  51  *                              section.  This is used to generate the kernel,
  52  *                              but makes no sense to be used by anyone else.
  53  *
  54  *    -z norelaxreloc           suppress the automatic addition of relaxed
  55  *                              relocations to GNU linkonce/COMDAT sections.
  56  *
  57  *    -z nosighandler           suppress the registration of the signal handler
  58  *                              used to manage SIGBUS.
  59  */
  60 
  61 /*
  62  * The following flags are committed, and will not be removed, but are
  63  * not publically documented, either because they are obsolete, or because
  64  * they exist to work around defects in other software and are not of
  65  * sufficient interest otherwise.
  66  *
  67  *    OPTION                    MEANING
  68  *
  69  *    -Wl,...                   compiler drivers and configuration tools
  70  *                              have been known to pass this compiler option
  71  *                              to ld(1).  Strip off the "-Wl," prefix and
  72  *                              process the remainder (...) as a normal option.
  73  */
  74 
  75 #include        <sys/link.h>
  76 #include        <stdio.h>
  77 #include        <fcntl.h>
  78 #include        <string.h>
  79 #include        <errno.h>
  80 #include        <elf.h>
  81 #include        <unistd.h>
  82 #include        <debug.h>
  83 #include        "msg.h"
  84 #include        "_libld.h"
  85 
  86 /*
  87  * Define a set of local argument flags, the settings of these will be
  88  * verified in check_flags() and lead to the appropriate output file flags
  89  * being initialized.
  90  */
  91 typedef enum {
  92         SET_UNKNOWN = -1,
  93         SET_FALSE = 0,
  94         SET_TRUE = 1
  95 } Setstate;
  96 
  97 static Setstate dflag   = SET_UNKNOWN;
  98 static Setstate zdflag  = SET_UNKNOWN;
  99 static Setstate Qflag   = SET_UNKNOWN;
 100 static Setstate Bdflag  = SET_UNKNOWN;
 101 static Setstate zfwflag = SET_UNKNOWN;
 102 
 103 static Boolean  aflag   = FALSE;
 104 static Boolean  bflag   = FALSE;
 105 static Boolean  rflag   = FALSE;
 106 static Boolean  sflag   = FALSE;
 107 static Boolean  zinflag = FALSE;
 108 static Boolean  zlflag  = FALSE;
 109 static Boolean  Bgflag  = FALSE;
 110 static Boolean  Blflag  = FALSE;
 111 static Boolean  Beflag  = FALSE;
 112 static Boolean  Bsflag  = FALSE;
 113 static Boolean  Dflag   = FALSE;
 114 static Boolean  Gflag   = FALSE;
 115 static Boolean  Vflag   = FALSE;
 116 
 117 /*
 118  * ztflag's state is set by pointing it to the matching string:
 119  *      text | textoff | textwarn
 120  */
 121 static const char       *ztflag = NULL;
 122 
 123 /*
 124  * Remember the guidance flags that result from the initial -z guidance
 125  * option, so that they can be compared to any that follow. We only want
 126  * to issue a warning when they differ.
 127  */
 128 static ofl_guideflag_t  initial_guidance_flags  = 0;
 129 
 130 static uintptr_t process_files_com(Ofl_desc *, int, char **);
 131 static uintptr_t process_flags_com(Ofl_desc *, int, char **, int *);
 132 
 133 /*
 134  * Print usage message to stderr - 2 modes, summary message only,
 135  * and full usage message.
 136  */
 137 static void
 138 usage_mesg(Boolean detail)
 139 {
 140         (void) fprintf(stderr, MSG_INTL(MSG_ARG_USAGE),
 141             MSG_ORIG(MSG_STR_OPTIONS));
 142 
 143         if (detail == FALSE)
 144                 return;
 145 
 146         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_3));
 147         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_6));
 148         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_A));
 149         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_B));
 150         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_CBDR));
 151         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_CBDY));
 152         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_CBE));
 153         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_CBG));
 154         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_CBL));
 155         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_CBR));
 156         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_CBS));
 157         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_C));
 158         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_CC));
 159         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_D));
 160         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_CD));
 161         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_E));
 162         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_F));
 163         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_CF));
 164         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_CG));
 165         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_H));
 166         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_I));
 167         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_CI));
 168         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_L));
 169         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_CL));
 170         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_M));
 171         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_CM));
 172         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_CN));
 173         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_O));
 174         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_P));
 175         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_CP));
 176         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_CQ));
 177         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_R));
 178         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_CR));
 179         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_S));
 180         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_CS));
 181         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_T));
 182         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_U));
 183         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_CV));
 184         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_CY));
 185         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZA));
 186         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZAE));
 187         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZAL));
 188         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZADLIB));
 189         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZC));
 190         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZDEF));
 191         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZDFS));
 192         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZDRS));
 193         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZE));
 194         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZFATW));
 195         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZFA));
 196         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZGP));
 197         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZGUIDE));
 198         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZH));
 199         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZIG));
 200         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZINA));
 201         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZINI));
 202         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZINT));
 203         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZLAZY));
 204         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZLD32));
 205         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZLD64));
 206         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZLO));
 207         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZM));
 208         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZNC));
 209         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZNDFS));
 210         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZNDEF));
 211         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZNDEL));
 212         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZNDLO));
 213         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZNDU));
 214         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZNLD));
 215         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZNOW));
 216         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZNPA));
 217         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZNV));
 218         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZO));
 219         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZPIA));
 220         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZRL));
 221         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZRREL));
 222         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZRS));
 223         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZRSN));
 224         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZRSGRP));
 225         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZSCAP));
 226         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZTARG));
 227         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZT));
 228         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZTO));
 229         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZTW));
 230         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZWRAP));
 231         (void) fprintf(stderr, MSG_INTL(MSG_ARG_DETAIL_ZVER));
 232 }
 233 
 234 /*
 235  * Rescan the archives seen on the command line in order
 236  * to handle circularly dependent archives, stopping when
 237  * no further member extraction occurs.
 238  *
 239  * entry:
 240  *      ofl - Output file descriptor
 241  *      isgrp - True if this is a an archive group search, False
 242  *              to search starting with argv[1] through end_arg_ndx
 243  *      end_arg_ndx - Index of final argv element to consider.
 244  */
 245 static uintptr_t
 246 ld_rescan_archives(Ofl_desc *ofl, int isgrp, int end_arg_ndx)
 247 {
 248         ofl->ofl_flags1 |= FLG_OF1_EXTRACT;
 249 
 250         while (ofl->ofl_flags1 & FLG_OF1_EXTRACT) {
 251                 Aliste          idx;
 252                 Ar_desc         *adp;
 253                 Word            start_ndx = isgrp ? ofl->ofl_ars_gsndx : 0;
 254                 Word            ndx = 0;
 255 
 256                 ofl->ofl_flags1 &= ~FLG_OF1_EXTRACT;
 257 
 258                 DBG_CALL(Dbg_file_ar_rescan(ofl->ofl_lml,
 259                     isgrp ? ofl->ofl_ars_gsandx : 1, end_arg_ndx));
 260 
 261                 for (APLIST_TRAVERSE(ofl->ofl_ars, idx, adp)) {
 262                         /* If not to starting index yet, skip it */
 263                         if (ndx++ < start_ndx)
 264                                 continue;
 265 
 266                         /*
 267                          * If this archive was processed with -z allextract,
 268                          * then all members have already been extracted.
 269                          */
 270                         if (adp->ad_elf == NULL)
 271                                 continue;
 272 
 273                         /*
 274                          * Reestablish any archive specific command line flags.
 275                          */
 276                         ofl->ofl_flags1 &= ~MSK_OF1_ARCHIVE;
 277                         ofl->ofl_flags1 |= (adp->ad_flags & MSK_OF1_ARCHIVE);
 278 
 279                         /*
 280                          * Re-process the archive.  Note that a file descriptor
 281                          * is unnecessary, as the file is already available in
 282                          * memory.
 283                          */
 284                         if (!ld_process_archive(adp->ad_name, -1, adp, ofl))
 285                                 return (S_ERROR);
 286                         if (ofl->ofl_flags & FLG_OF_FATAL)
 287                                 return (1);
 288                 }
 289         }
 290 
 291         return (1);
 292 }
 293 
 294 /*
 295  * Checks the command line option flags for consistency.
 296  */
 297 static uintptr_t
 298 check_flags(Ofl_desc * ofl, int argc)
 299 {
 300         /*
 301          * If the user specified -zguidance=noall, then we can safely disable
 302          * the entire feature. The purpose of -zguidance=noall is to allow
 303          * the user to override guidance specified from a makefile via
 304          * the LD_OPTIONS environment variable, and so, we want to behave
 305          * in exactly the same manner we would have if no option were present.
 306          */
 307         if ((ofl->ofl_guideflags & (FLG_OFG_ENABLE | FLG_OFG_NO_ALL)) ==
 308             (FLG_OFG_ENABLE | FLG_OFG_NO_ALL))
 309                 ofl->ofl_guideflags &= ~FLG_OFG_ENABLE;
 310 
 311         if (Plibpath && (Llibdir || Ulibdir))
 312                 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_ARG_YP),
 313                     Llibdir ? 'L' : 'U');
 314 
 315         if (rflag) {
 316                 if (dflag == SET_UNKNOWN)
 317                         dflag = SET_FALSE;
 318                 /*
 319                  * Combining relocations when building a relocatable
 320                  * object isn't allowed.  Warn the user, but proceed.
 321                  */
 322                 if (ofl->ofl_flags & FLG_OF_COMREL)
 323                         ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_MARG_INCOMP),
 324                             MSG_INTL(MSG_MARG_REL),
 325                             MSG_ORIG(MSG_ARG_ZCOMBRELOC));
 326                 ofl->ofl_flags |= FLG_OF_RELOBJ;
 327         } else {
 328                 /*
 329                  * Translating object capabilities to symbol capabilities is
 330                  * only meaningful when creating a relocatable object.
 331                  */
 332                 if (ofl->ofl_flags & FLG_OF_OTOSCAP)
 333                         ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_MARG_ONLY),
 334                             MSG_ORIG(MSG_ARG_ZSYMBOLCAP),
 335                             MSG_INTL(MSG_MARG_REL));
 336 
 337                 /*
 338                  * If the user hasn't explicitly requested that relocations
 339                  * not be combined, combine them by default.
 340                  */
 341                 if ((ofl->ofl_flags & FLG_OF_NOCOMREL) == 0)
 342                         ofl->ofl_flags |= FLG_OF_COMREL;
 343         }
 344 
 345         if (zdflag == SET_TRUE)
 346                 ofl->ofl_flags |= FLG_OF_NOUNDEF;
 347 
 348         if (zinflag)
 349                 ofl->ofl_dtflags_1 |= DF_1_INTERPOSE;
 350 
 351         if (sflag)
 352                 ofl->ofl_flags |= FLG_OF_STRIP;
 353 
 354         if (Qflag == SET_TRUE)
 355                 ofl->ofl_flags |= FLG_OF_ADDVERS;
 356 
 357         if (Blflag)
 358                 ofl->ofl_flags |= FLG_OF_AUTOLCL;
 359 
 360         if (Beflag)
 361                 ofl->ofl_flags |= FLG_OF_AUTOELM;
 362 
 363         if (Blflag && Beflag)
 364                 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_ARG_INCOMP),
 365                     MSG_ORIG(MSG_ARG_BELIMINATE), MSG_ORIG(MSG_ARG_BLOCAL));
 366 
 367         if (ofl->ofl_interp && (ofl->ofl_flags1 & FLG_OF1_NOINTRP))
 368                 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_ARG_INCOMP),
 369                     MSG_ORIG(MSG_ARG_CI), MSG_ORIG(MSG_ARG_ZNOINTERP));
 370 
 371         if ((ofl->ofl_flags1 & (FLG_OF1_NRLXREL | FLG_OF1_RLXREL)) ==
 372             (FLG_OF1_NRLXREL | FLG_OF1_RLXREL))
 373                 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_ARG_INCOMP),
 374                     MSG_ORIG(MSG_ARG_ZRELAXRELOC),
 375                     MSG_ORIG(MSG_ARG_ZNORELAXRELOC));
 376 
 377         if (ofl->ofl_filtees && !Gflag)
 378                 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_MARG_ST_ONLYAVL),
 379                     ((ofl->ofl_flags & FLG_OF_AUX) ?
 380                     MSG_INTL(MSG_MARG_FILTER_AUX) : MSG_INTL(MSG_MARG_FILTER)));
 381 
 382         if (dflag != SET_FALSE) {
 383                 /*
 384                  * Set -Bdynamic on by default, setting is rechecked as input
 385                  * files are processed.
 386                  */
 387                 ofl->ofl_flags |=
 388                     (FLG_OF_DYNAMIC | FLG_OF_DYNLIBS | FLG_OF_PROCRED);
 389 
 390                 if (aflag)
 391                         ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_ARG_INCOMP),
 392                             MSG_ORIG(MSG_ARG_DY), MSG_ORIG(MSG_ARG_A));
 393 
 394                 if (bflag)
 395                         ofl->ofl_flags |= FLG_OF_BFLAG;
 396 
 397                 if (Bgflag == TRUE) {
 398                         if (zdflag == SET_FALSE)
 399                                 ld_eprintf(ofl, ERR_FATAL,
 400                                     MSG_INTL(MSG_ARG_INCOMP),
 401                                     MSG_ORIG(MSG_ARG_BGROUP),
 402                                     MSG_ORIG(MSG_ARG_ZNODEF));
 403                         ofl->ofl_dtflags_1 |= DF_1_GROUP;
 404                         ofl->ofl_flags |= FLG_OF_NOUNDEF;
 405                 }
 406 
 407                 /*
 408                  * If the use of default library searching has been suppressed
 409                  * but no runpaths have been provided we're going to have a hard
 410                  * job running this object.
 411                  */
 412                 if ((ofl->ofl_dtflags_1 & DF_1_NODEFLIB) && !ofl->ofl_rpath)
 413                         ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_ARG_NODEFLIB),
 414                             MSG_INTL(MSG_MARG_RPATH));
 415 
 416                 /*
 417                  * By default, text relocation warnings are given when building
 418                  * an executable unless the -b flag is specified.  This option
 419                  * implies that unclean text can be created, so no warnings are
 420                  * generated unless specifically asked for.
 421                  */
 422                 if ((ztflag == MSG_ORIG(MSG_ARG_ZTEXTOFF)) ||
 423                     ((ztflag == NULL) && bflag)) {
 424                         ofl->ofl_flags1 |= FLG_OF1_TEXTOFF;
 425                         ofl->ofl_guideflags |= FLG_OFG_NO_TEXT;
 426                 } else if (ztflag == MSG_ORIG(MSG_ARG_ZTEXT)) {
 427                         ofl->ofl_flags |= FLG_OF_PURETXT;
 428                         ofl->ofl_guideflags |= FLG_OFG_NO_TEXT;
 429                 }
 430 
 431                 if (Gflag || !rflag) {
 432                         /*
 433                          * Create a dynamic object.  -Bdirect indicates that all
 434                          * references should be bound directly.  This also
 435                          * enables lazyloading.  Individual symbols can be
 436                          * bound directly (or not) using mapfiles and the
 437                          * DIRECT (NODIRECT) qualifier.  With this capability,
 438                          * each syminfo entry is tagged SYMINFO_FLG_DIRECTBIND.
 439                          * Prior to this per-symbol direct binding, runtime
 440                          * direct binding was controlled via the DF_1_DIRECT
 441                          * flag.  This flag affected all references from the
 442                          * object.  -Bdirect continues to set this flag, and
 443                          * thus provides a means of taking a newly built
 444                          * direct binding object back to older systems.
 445                          *
 446                          * NOTE, any use of per-symbol NODIRECT bindings, or
 447                          * -znodirect, will disable the creation of the
 448                          * DF_1_DIRECT flag.  Older runtime linkers do not
 449                          * have the capability to do per-symbol direct bindings.
 450                          */
 451                         if (Bdflag == SET_TRUE) {
 452                                 ofl->ofl_dtflags_1 |= DF_1_DIRECT;
 453                                 ofl->ofl_flags1 |= FLG_OF1_LAZYLD;
 454                                 ofl->ofl_guideflags |= FLG_OFG_NO_LAZY;
 455                                 ofl->ofl_flags |= FLG_OF_SYMINFO;
 456                         }
 457 
 458                         /*
 459                          * -Bnodirect disables directly binding to any symbols
 460                          * exported from the object being created.  Individual
 461                          * references to external objects can still be affected
 462                          * by -zdirect or mapfile DIRECT directives.
 463                          */
 464                         if (Bdflag == SET_FALSE) {
 465                                 ofl->ofl_flags1 |= (FLG_OF1_NDIRECT |
 466                                     FLG_OF1_NGLBDIR | FLG_OF1_ALNODIR);
 467                                 ofl->ofl_flags |= FLG_OF_SYMINFO;
 468                         }
 469                 }
 470 
 471                 if (!Gflag && !rflag) {
 472                         /*
 473                          * Dynamically linked executable.
 474                          */
 475                         ofl->ofl_flags |= FLG_OF_EXEC;
 476 
 477                         if (zdflag != SET_FALSE)
 478                                 ofl->ofl_flags |= FLG_OF_NOUNDEF;
 479 
 480                         /*
 481                          * -z textwarn is the default for executables, and
 482                          * only an explicit -z text* option can change that,
 483                          * so there's no need to provide additional guidance.
 484                          */
 485                         ofl->ofl_guideflags |= FLG_OFG_NO_TEXT;
 486 
 487                         if (Bsflag)
 488                                 ld_eprintf(ofl, ERR_FATAL,
 489                                     MSG_INTL(MSG_ARG_DY_INCOMP),
 490                                     MSG_ORIG(MSG_ARG_BSYMBOLIC));
 491                         if (ofl->ofl_soname)
 492                                 ld_eprintf(ofl, ERR_FATAL,
 493                                     MSG_INTL(MSG_MARG_DY_INCOMP),
 494                                     MSG_INTL(MSG_MARG_SONAME));
 495                 } else if (!rflag) {
 496                         /*
 497                          * Shared library.
 498                          */
 499                         ofl->ofl_flags |= FLG_OF_SHAROBJ;
 500 
 501                         /*
 502                          * By default, print text relocation warnings for
 503                          * executables but *not* for shared objects. However,
 504                          * if -z guidance is on, issue warnings for shared
 505                          * objects as well.
 506                          *
 507                          * If -z textwarn is explicitly specified, also issue
 508                          * guidance messages if -z guidance is on, but not
 509                          * for -z text or -z textoff.
 510                          */
 511                         if (ztflag == NULL) {
 512                                 if (!OFL_GUIDANCE(ofl, FLG_OFG_NO_TEXT))
 513                                         ofl->ofl_flags1 |= FLG_OF1_TEXTOFF;
 514                         } else if ((ofl->ofl_flags & FLG_OF_PURETXT) ||
 515                             (ofl->ofl_flags1 & FLG_OF1_TEXTOFF)) {
 516                                 ofl->ofl_guideflags |= FLG_OFG_NO_TEXT;
 517                         }
 518 
 519                         if (Bsflag) {
 520                                 /*
 521                                  * -Bsymbolic, and -Bnodirect make no sense.
 522                                  */
 523                                 if (Bdflag == SET_FALSE)
 524                                         ld_eprintf(ofl, ERR_FATAL,
 525                                             MSG_INTL(MSG_ARG_INCOMP),
 526                                             MSG_ORIG(MSG_ARG_BSYMBOLIC),
 527                                             MSG_ORIG(MSG_ARG_BNODIRECT));
 528                                 ofl->ofl_flags |= FLG_OF_SYMBOLIC;
 529                                 ofl->ofl_dtflags |= DF_SYMBOLIC;
 530                         }
 531                 } else {
 532                         /*
 533                          * Dynamic relocatable object.
 534                          */
 535                         if (ztflag == NULL)
 536                                 ofl->ofl_flags1 |= FLG_OF1_TEXTOFF;
 537                         ofl->ofl_guideflags |= FLG_OFG_NO_TEXT;
 538 
 539                         if (ofl->ofl_interp)
 540                                 ld_eprintf(ofl, ERR_FATAL,
 541                                     MSG_INTL(MSG_MARG_INCOMP),
 542                                     MSG_INTL(MSG_MARG_REL),
 543                                     MSG_ORIG(MSG_ARG_CI));
 544                 }
 545         } else {
 546                 ofl->ofl_flags |= FLG_OF_STATIC;
 547 
 548                 if (bflag)
 549                         ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_ARG_ST_INCOMP),
 550                             MSG_ORIG(MSG_ARG_B));
 551                 if (ofl->ofl_soname)
 552                         ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_MARG_ST_INCOMP),
 553                             MSG_INTL(MSG_MARG_SONAME));
 554                 if (ofl->ofl_depaudit)
 555                         ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_ARG_ST_INCOMP),
 556                             MSG_ORIG(MSG_ARG_CP));
 557                 if (ofl->ofl_audit)
 558                         ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_ARG_ST_INCOMP),
 559                             MSG_ORIG(MSG_ARG_P));
 560                 if (ofl->ofl_config)
 561                         ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_ARG_ST_INCOMP),
 562                             MSG_ORIG(MSG_ARG_C));
 563                 if (ztflag)
 564                         ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_ARG_ST_INCOMP),
 565                             MSG_ORIG(MSG_ARG_ZTEXTALL));
 566                 if (Gflag)
 567                         ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_MARG_ST_INCOMP),
 568                             MSG_INTL(MSG_MARG_SO));
 569                 if (aflag && rflag)
 570                         ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_MARG_INCOMP),
 571                             MSG_ORIG(MSG_ARG_A), MSG_INTL(MSG_MARG_REL));
 572 
 573                 if (rflag) {
 574                         /*
 575                          * We can only strip the symbol table and string table
 576                          * if no output relocations will refer to them.
 577                          */
 578                         if (sflag)
 579                                 ld_eprintf(ofl, ERR_WARNING,
 580                                     MSG_INTL(MSG_ARG_STRIP),
 581                                     MSG_INTL(MSG_MARG_REL),
 582                                     MSG_INTL(MSG_MARG_STRIP));
 583 
 584                         if (ztflag == NULL)
 585                                 ofl->ofl_flags1 |= FLG_OF1_TEXTOFF;
 586                         ofl->ofl_guideflags |= FLG_OFG_NO_TEXT;
 587 
 588                         if (ofl->ofl_interp)
 589                                 ld_eprintf(ofl, ERR_FATAL,
 590                                     MSG_INTL(MSG_MARG_INCOMP),
 591                                     MSG_INTL(MSG_MARG_REL),
 592                                     MSG_ORIG(MSG_ARG_CI));
 593                 } else {
 594                         /*
 595                          * Static executable.
 596                          */
 597                         ofl->ofl_flags |= FLG_OF_EXEC | FLG_OF_PROCRED;
 598 
 599                         if (zdflag != SET_FALSE)
 600                                 ofl->ofl_flags |= FLG_OF_NOUNDEF;
 601                 }
 602         }
 603 
 604         /*
 605          * If the user didn't supply an output file name supply a default.
 606          */
 607         if (ofl->ofl_name == NULL)
 608                 ofl->ofl_name = MSG_ORIG(MSG_STR_AOUT);
 609 
 610         /*
 611          * We set the entrance criteria after all input argument processing as
 612          * it is only at this point we're sure what the output image will be
 613          * (static or dynamic).
 614          */
 615         if (ld_ent_setup(ofl, ld_targ.t_m.m_segm_align) == S_ERROR)
 616                 return (S_ERROR);
 617 
 618         /*
 619          * Does the host currently running the linker have the same
 620          * byte order as the target for which the object is being produced?
 621          * If not, set FLG_OF1_ENCDIFF so relocation code will know
 622          * to check.
 623          */
 624         if (_elf_sys_encoding() != ld_targ.t_m.m_data)
 625                 ofl->ofl_flags1 |= FLG_OF1_ENCDIFF;
 626 
 627         /*
 628          * If the target has special executable section filling requirements,
 629          * register the fill function with libelf
 630          */
 631         if (ld_targ.t_ff.ff_execfill != NULL)
 632                 _elf_execfill(ld_targ.t_ff.ff_execfill);
 633 
 634         /*
 635          * Initialize string tables.  Symbol definitions within mapfiles can
 636          * result in the creation of input sections.
 637          */
 638         if (ld_init_strings(ofl) == S_ERROR)
 639                 return (S_ERROR);
 640 
 641         /*
 642          * Process mapfiles. Mapfile can redefine or add sections/segments,
 643          * so this must come after the default entrance criteria are established
 644          * (above).
 645          */
 646         if (ofl->ofl_maps) {
 647                 const char      *name;
 648                 Aliste          idx;
 649 
 650                 for (APLIST_TRAVERSE(ofl->ofl_maps, idx, name))
 651                         if (!ld_map_parse(name, ofl))
 652                                 return (S_ERROR);
 653 
 654                 if (!ld_map_post_process(ofl))
 655                         return (S_ERROR);
 656         }
 657 
 658         /*
 659          * If a mapfile has been used to define a single symbolic scope of
 660          * interfaces, -Bsymbolic is established.  This global setting goes
 661          * beyond individual symbol protection, and ensures all relocations
 662          * (even those that reference section symbols) are processed within
 663          * the object being built.
 664          */
 665         if (((ofl->ofl_flags &
 666             (FLG_OF_MAPSYMB | FLG_OF_MAPGLOB)) == FLG_OF_MAPSYMB) &&
 667             (ofl->ofl_flags & (FLG_OF_AUTOLCL | FLG_OF_AUTOELM))) {
 668                 ofl->ofl_flags |= FLG_OF_SYMBOLIC;
 669                 ofl->ofl_dtflags |= DF_SYMBOLIC;
 670         }
 671 
 672         /*
 673          * If -zloadfltr is set, verify that filtering is in effect.  Filters
 674          * are either established from the command line, and affect the whole
 675          * object, or are set on a per-symbol basis from a mapfile.
 676          */
 677         if (zlflag) {
 678                 if ((ofl->ofl_filtees == NULL) && (ofl->ofl_dtsfltrs == NULL))
 679                         ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_ARG_NOFLTR),
 680                             MSG_ORIG(MSG_ARG_ZLOADFLTR));
 681                 ofl->ofl_dtflags_1 |= DF_1_LOADFLTR;
 682         }
 683 
 684         /*
 685          * Check that we have something to work with. This check is carried out
 686          * after mapfile processing as its possible a mapfile is being used to
 687          * define symbols, in which case it would be sufficient to build the
 688          * output file purely from the mapfile.
 689          */
 690         if ((ofl->ofl_objscnt == 0) && (ofl->ofl_soscnt == 0)) {
 691                 if ((Vflag ||
 692                     (Dflag && (dbg_desc->d_extra & DBG_E_HELP_EXIT))) &&
 693                     (argc == 2)) {
 694                         ofl->ofl_flags1 |= FLG_OF1_DONE;
 695                 } else {
 696                         ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_ARG_NOFILES));
 697                         return (S_ERROR);
 698                 }
 699         }
 700         return (1);
 701 }
 702 
 703 /*
 704  * Decompose the string pointed by optarg into argv[][] so that argv[][] can be
 705  * used as an argument to getopt().
 706  *
 707  * If the second argument 'usage' is not NULL, then this is called from the
 708  * first pass. Else this is called from the second pass.
 709  */
 710 static uintptr_t
 711 createargv(Ofl_desc *ofl, int *usage)
 712 {
 713         int             argc = 0, idx = 0, ooptind;
 714         uintptr_t       ret;
 715         char            **argv, *p0;
 716 
 717         /*
 718          * The argument being examined is either:
 719          *      ld32=   or
 720          *      ld64=
 721          */
 722 #if     defined(_LP64)
 723         if (optarg[2] == '3')
 724                 return (0);
 725 #else
 726         if (optarg[2] == '6')
 727                 return (0);
 728 #endif
 729 
 730         p0 = &optarg[5];
 731 
 732         /*
 733          * Count the number of arguments.
 734          */
 735         while (*p0) {
 736                 /*
 737                  * Pointing at non-separator character.
 738                  */
 739                 if (*p0 != ',') {
 740                         argc++;
 741                         while (*p0 && (*p0 != ','))
 742                                 p0++;
 743                         continue;
 744                 }
 745 
 746                 /*
 747                  * Pointing at a separator character.
 748                  */
 749                 if (*p0 == ',') {
 750                         while (*p0 == ',')
 751                                 p0++;
 752                         continue;
 753                 }
 754         }
 755 
 756         if (argc == 0)
 757                 return (0);
 758 
 759         /*
 760          * Allocate argument vector.
 761          */
 762         if ((p0 = (char *)strdup(&optarg[5])) == NULL)
 763                 return (S_ERROR);
 764         if ((argv = libld_malloc((sizeof (char *)) * (argc + 1))) == NULL)
 765                 return (S_ERROR);
 766 
 767         while (*p0) {
 768                 char *p;
 769 
 770                 /*
 771                  * Pointing at the beginning of non-separator character string.
 772                  */
 773                 if (*p0 != ',') {
 774                         p = p0;
 775                         while (*p0 && (*p0 != ','))
 776                                 p0++;
 777                         argv[idx++] = p;
 778                         if (*p0) {
 779                                 *p0 = '\0';
 780                                 p0++;
 781                         }
 782                         continue;
 783                 }
 784 
 785                 /*
 786                  * Pointing at the beginining of separator character string.
 787                  */
 788                 if (*p0 == ',') {
 789                         while (*p0 == ',')
 790                                 p0++;
 791                         continue;
 792                 }
 793         }
 794         argv[idx] = 0;
 795         ooptind = optind;
 796         optind = 0;
 797 
 798         /*
 799          * Dispatch to pass1 or pass2
 800          */
 801         if (usage)
 802                 ret = process_flags_com(ofl, argc, argv, usage);
 803         else
 804                 ret = process_files_com(ofl, argc, argv);
 805 
 806         optind = ooptind;
 807         return (ret);
 808 }
 809 
 810 /*
 811  * Parse the items in a '-z guidance' value, and set the ofl_guideflags.
 812  * A guidance option looks like this:
 813  *
 814  *      -z guidance[=item1,item2,...]
 815  *
 816  * Where each item specifies categories of guidance messages to suppress,
 817  * each starting with the prefix 'no'. We allow arbitrary whitespace between
 818  * the items, allow multiple ',' delimiters without an intervening item, and
 819  * quietly ignore any items we don't recognize.
 820  *
 821  * -    Such items are likely to be known to newer versions of the linker,
 822  *      and we do not want an older version of the linker to
 823  *      complain about them.
 824  *
 825  * -    Times and standards can change, and so we wish to reserve the
 826  *      right to make an old item that no longer makes sense go away.
 827  *      Quietly ignoring unrecognized items facilitates this.
 828  *
 829  * However, we always display unrecognized items in debug output.
 830  *
 831  * entry:
 832  *      ofl - Output descriptor
 833  *      optarg - option string to be processed. This will either be a NULL
 834  *              terminated 'guidance', or it will be 'guidance=' followed
 835  *              by the item tokens as described above.
 836  *
 837  * exit:
 838  *      Returns TRUE (1) on success, FALSE (0) on failure.
 839  *
 840  */
 841 static Boolean
 842 guidance_parse(Ofl_desc *ofl, char *optarg)
 843 {
 844         typedef struct {
 845                 const char      *name;
 846                 ofl_guideflag_t flag;
 847         } item_desc;
 848 
 849         static  item_desc items[] = {
 850                 { MSG_ORIG(MSG_ARG_GUIDE_NO_ALL),       FLG_OFG_NO_ALL },
 851 
 852                 { MSG_ORIG(MSG_ARG_GUIDE_NO_DEFS),      FLG_OFG_NO_DEFS },
 853                 { MSG_ORIG(MSG_ARG_GUIDE_NO_DIRECT),    FLG_OFG_NO_DB },
 854                 { MSG_ORIG(MSG_ARG_GUIDE_NO_LAZYLOAD),  FLG_OFG_NO_LAZY },
 855                 { MSG_ORIG(MSG_ARG_GUIDE_NO_MAPFILE),   FLG_OFG_NO_MF },
 856                 { MSG_ORIG(MSG_ARG_GUIDE_NO_TEXT),      FLG_OFG_NO_TEXT },
 857                 { MSG_ORIG(MSG_ARG_GUIDE_NO_UNUSED),    FLG_OFG_NO_UNUSED },
 858                 { NULL,                                 0 }
 859         };
 860 
 861         char            *lasts, *name;
 862         item_desc       *item;
 863         ofl_guideflag_t ofl_guideflags = FLG_OFG_ENABLE;
 864 
 865         /*
 866          * Skip the 'guidance' prefix. If NULL terminated, there are no
 867          * item values to parse. Otherwise, skip the '=' and parse the items.
 868          */
 869         optarg += MSG_ARG_GUIDE_SIZE;
 870         if (*optarg == '=') {
 871                 optarg++;
 872 
 873                 if ((name = libld_malloc(strlen(optarg) + 1)) == NULL)
 874                         return (FALSE);
 875                 (void) strcpy(name, optarg);
 876 
 877                 if ((name = strtok_r(name, MSG_ORIG(MSG_ARG_GUIDE_DELIM),
 878                     &lasts)) != NULL) {
 879                         do {
 880                                 for (item = items; item->name != NULL; item++)
 881                                         if (strcasecmp(name, item->name) == 0)
 882                                                 break;
 883                                 if (item->name == NULL) {
 884                                         DBG_CALL(Dbg_args_guidance_unknown(
 885                                             ofl->ofl_lml, name));
 886                                         continue;
 887                                 }
 888                                 ofl_guideflags |= item->flag;
 889                         } while ((name = strtok_r(NULL,
 890                             MSG_ORIG(MSG_ARG_GUIDE_DELIM), &lasts)) != NULL);
 891                 }
 892         }
 893 
 894         /*
 895          * If -zguidance is used more than once, we take the first one. We
 896          * do this quietly if they have identical options, and with a warning
 897          * otherwise.
 898          */
 899         if ((initial_guidance_flags & FLG_OFG_ENABLE) &&
 900             (ofl_guideflags != initial_guidance_flags)) {
 901                 ld_eprintf(ofl, ERR_WARNING_NF, MSG_INTL(MSG_ARG_MTONCE),
 902                     MSG_ORIG(MSG_ARG_ZGUIDE));
 903                 return (TRUE);
 904         }
 905 
 906         /*
 907          * First time: Save the flags for comparison to any subsequent
 908          * -z guidance that comes along, and OR the resulting flags into
 909          * the flags kept in the output descriptor.
 910          */
 911         initial_guidance_flags = ofl_guideflags;
 912         ofl->ofl_guideflags |= ofl_guideflags;
 913         return (TRUE);
 914 }
 915 
 916 /*
 917  * Parse the -z assert-deflib option. This option can appear in two different
 918  * forms:
 919  *      -z assert-deflib
 920  *      -z assert-deflib=libfred.so
 921  *
 922  * Either form enables this option, the latter form marks libfred.so as an
 923  * exempt library from the check. It is valid to have multiple invocations of
 924  * the second form. We silently ignore mulitple occurrences of the first form
 925  * and multiple invocations of the first form when the second form also occurs.
 926  *
 927  * We only return false when we have an internal error, such as the failure of
 928  * aplist_append. Every other time we return true, but we have the appropriate
 929  * fatal flags set beacuse of the ld_eprintf.
 930  */
 931 static int
 932 assdeflib_parse(Ofl_desc *ofl, char *optarg)
 933 {
 934         size_t olen, mlen;
 935         ofl->ofl_flags |= FLG_OF_ADEFLIB;
 936 
 937         olen = strlen(optarg);
 938         /* Minimum size of assert-deflib=lib%s.so */
 939         mlen = MSG_ARG_ASSDEFLIB_SIZE + 1 + MSG_STR_LIB_SIZE +
 940             MSG_STR_SOEXT_SIZE;
 941         if (olen > MSG_ARG_ASSDEFLIB_SIZE) {
 942                 if (optarg[MSG_ARG_ASSDEFLIB_SIZE] != '=') {
 943                         ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_ARG_ILLEGAL),
 944                             MSG_ORIG(MSG_ARG_ASSDEFLIB), optarg);
 945                         return (TRUE);
 946                 }
 947 
 948                 if (strncmp(optarg + MSG_ARG_ASSDEFLIB_SIZE + 1,
 949                     MSG_ORIG(MSG_STR_LIB), MSG_STR_LIB_SIZE) != 0 ||
 950                     strcmp(optarg + olen - MSG_STR_SOEXT_SIZE,
 951                     MSG_ORIG(MSG_STR_SOEXT)) != 0 || olen <= mlen) {
 952                         ld_eprintf(ofl, ERR_FATAL,
 953                             MSG_INTL(MSG_ARG_ASSDEFLIB_MALFORMED), optarg);
 954                         return (TRUE);
 955                 }
 956 
 957                 if (aplist_append(&ofl->ofl_assdeflib, optarg +
 958                     MSG_ARG_ASSDEFLIB_SIZE + 1, AL_CNT_ASSDEFLIB) == NULL)
 959                         return (FALSE);
 960         }
 961 
 962         return (TRUE);
 963 }
 964 
 965 static int      optitle = 0;
 966 /*
 967  * Parsing options pass1 for process_flags().
 968  */
 969 static uintptr_t
 970 parseopt_pass1(Ofl_desc *ofl, int argc, char **argv, int *usage)
 971 {
 972         int     c, ndx = optind;
 973 
 974         /*
 975          * The -32, -64 and -ztarget options are special, in that we validate
 976          * them, but otherwise ignore them. libld.so (this code) is called
 977          * from the ld front end program. ld has already examined the
 978          * arguments to determine the output class and machine type of the
 979          * output object, as reflected in the version (32/64) of ld_main()
 980          * that was called and the value of the 'mach' argument passed.
 981          * By time execution reaches this point, these options have already
 982          * been seen and acted on.
 983          */
 984         while ((c = ld_getopt(ofl->ofl_lml, ndx, argc, argv)) != -1) {
 985 
 986                 switch (c) {
 987                 case '3':
 988                         DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c, optarg));
 989 
 990                         /*
 991                          * -32 is processed by ld to determine the output class.
 992                          * Here we sanity check the option incase some other
 993                          * -3* option is mistakenly passed to us.
 994                          */
 995                         if (optarg[0] != '2')
 996                                 ld_eprintf(ofl, ERR_FATAL,
 997                                     MSG_INTL(MSG_ARG_ILLEGAL),
 998                                     MSG_ORIG(MSG_ARG_3), optarg);
 999                         continue;
1000 
1001                 case '6':
1002                         DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c, optarg));
1003 
1004                         /*
1005                          * -64 is processed by ld to determine the output class.
1006                          * Here we sanity check the option incase some other
1007                          * -6* option is mistakenly passed to us.
1008                          */
1009                         if (optarg[0] != '4')
1010                                 ld_eprintf(ofl, ERR_FATAL,
1011                                     MSG_INTL(MSG_ARG_ILLEGAL),
1012                                     MSG_ORIG(MSG_ARG_6), optarg);
1013                         continue;
1014 
1015                 case 'a':
1016                         DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c, NULL));
1017                         aflag = TRUE;
1018                         break;
1019 
1020                 case 'b':
1021                         DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c, NULL));
1022                         bflag = TRUE;
1023 
1024                         /*
1025                          * This is a hack, and may be undone later.
1026                          * The -b option is only used to build the Unix
1027                          * kernel and its related kernel-mode modules.
1028                          * We do not want those files to get a .SUNW_ldynsym
1029                          * section. At least for now, the kernel makes no
1030                          * use of .SUNW_ldynsym, and we do not want to use
1031                          * the space to hold it. Therefore, we overload
1032                          * the use of -b to also imply -znoldynsym.
1033                          */
1034                         ofl->ofl_flags |= FLG_OF_NOLDYNSYM;
1035                         break;
1036 
1037                 case 'c':
1038                         DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c, optarg));
1039                         if (ofl->ofl_config)
1040                                 ld_eprintf(ofl, ERR_WARNING_NF,
1041                                     MSG_INTL(MSG_ARG_MTONCE),
1042                                     MSG_ORIG(MSG_ARG_C));
1043                         else
1044                                 ofl->ofl_config = optarg;
1045                         break;
1046 
1047                 case 'C':
1048                         DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c, NULL));
1049                         demangle_flag = 1;
1050                         break;
1051 
1052                 case 'd':
1053                         DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c, optarg));
1054                         if ((optarg[0] == 'n') && (optarg[1] == '\0')) {
1055                                 if (dflag != SET_UNKNOWN)
1056                                         ld_eprintf(ofl, ERR_WARNING_NF,
1057                                             MSG_INTL(MSG_ARG_MTONCE),
1058                                             MSG_ORIG(MSG_ARG_D));
1059                                 else
1060                                         dflag = SET_FALSE;
1061                         } else if ((optarg[0] == 'y') && (optarg[1] == '\0')) {
1062                                 if (dflag != SET_UNKNOWN)
1063                                         ld_eprintf(ofl, ERR_WARNING_NF,
1064                                             MSG_INTL(MSG_ARG_MTONCE),
1065                                             MSG_ORIG(MSG_ARG_D));
1066                                 else
1067                                         dflag = SET_TRUE;
1068                         } else {
1069                                 ld_eprintf(ofl, ERR_FATAL,
1070                                     MSG_INTL(MSG_ARG_ILLEGAL),
1071                                     MSG_ORIG(MSG_ARG_D), optarg);
1072                         }
1073                         break;
1074 
1075                 case 'e':
1076                         DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c, optarg));
1077                         if (ofl->ofl_entry)
1078                                 ld_eprintf(ofl, ERR_WARNING_NF,
1079                                     MSG_INTL(MSG_MARG_MTONCE),
1080                                     MSG_INTL(MSG_MARG_ENTRY));
1081                         else
1082                                 ofl->ofl_entry = (void *)optarg;
1083                         break;
1084 
1085                 case 'f':
1086                         DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c, optarg));
1087                         if (ofl->ofl_filtees &&
1088                             (!(ofl->ofl_flags & FLG_OF_AUX))) {
1089                                 ld_eprintf(ofl, ERR_FATAL,
1090                                     MSG_INTL(MSG_MARG_INCOMP),
1091                                     MSG_INTL(MSG_MARG_FILTER_AUX),
1092                                     MSG_INTL(MSG_MARG_FILTER));
1093                         } else {
1094                                 if ((ofl->ofl_filtees =
1095                                     add_string(ofl->ofl_filtees, optarg)) ==
1096                                     (const char *)S_ERROR)
1097                                         return (S_ERROR);
1098                                 ofl->ofl_flags |= FLG_OF_AUX;
1099                         }
1100                         break;
1101 
1102                 case 'F':
1103                         DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c, optarg));
1104                         if (ofl->ofl_filtees &&
1105                             (ofl->ofl_flags & FLG_OF_AUX)) {
1106                                 ld_eprintf(ofl, ERR_FATAL,
1107                                     MSG_INTL(MSG_MARG_INCOMP),
1108                                     MSG_INTL(MSG_MARG_FILTER),
1109                                     MSG_INTL(MSG_MARG_FILTER_AUX));
1110                         } else {
1111                                 if ((ofl->ofl_filtees =
1112                                     add_string(ofl->ofl_filtees, optarg)) ==
1113                                     (const char *)S_ERROR)
1114                                         return (S_ERROR);
1115                         }
1116                         break;
1117 
1118                 case 'h':
1119                         DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c, optarg));
1120                         if (ofl->ofl_soname)
1121                                 ld_eprintf(ofl, ERR_WARNING_NF,
1122                                     MSG_INTL(MSG_MARG_MTONCE),
1123                                     MSG_INTL(MSG_MARG_SONAME));
1124                         else
1125                                 ofl->ofl_soname = (const char *)optarg;
1126                         break;
1127 
1128                 case 'i':
1129                         DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c, NULL));
1130                         ofl->ofl_flags |= FLG_OF_IGNENV;
1131                         break;
1132 
1133                 case 'I':
1134                         DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c, optarg));
1135                         if (ofl->ofl_interp)
1136                                 ld_eprintf(ofl, ERR_WARNING_NF,
1137                                     MSG_INTL(MSG_ARG_MTONCE),
1138                                     MSG_ORIG(MSG_ARG_CI));
1139                         else
1140                                 ofl->ofl_interp = (const char *)optarg;
1141                         break;
1142 
1143                 case 'l':
1144                         DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c, optarg));
1145                         /*
1146                          * For now, count any library as a shared object.  This
1147                          * is used to size the internal symbol cache.  This
1148                          * value is recalculated later on actual file processing
1149                          * to get an accurate shared object count.
1150                          */
1151                         ofl->ofl_soscnt++;
1152                         break;
1153 
1154                 case 'm':
1155                         DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c, NULL));
1156                         ofl->ofl_flags |= FLG_OF_GENMAP;
1157                         break;
1158 
1159                 case 'o':
1160                         DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c, optarg));
1161                         if (ofl->ofl_name)
1162                                 ld_eprintf(ofl, ERR_WARNING_NF,
1163                                     MSG_INTL(MSG_MARG_MTONCE),
1164                                     MSG_INTL(MSG_MARG_OUTFILE));
1165                         else
1166                                 ofl->ofl_name = (const char *)optarg;
1167                         break;
1168 
1169                 case 'p':
1170                         DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c, optarg));
1171 
1172                         /*
1173                          * Multiple instances of this option may occur.  Each
1174                          * additional instance is effectively concatenated to
1175                          * the previous separated by a colon.
1176                          */
1177                         if (*optarg != '\0') {
1178                                 if ((ofl->ofl_audit =
1179                                     add_string(ofl->ofl_audit,
1180                                     optarg)) == (const char *)S_ERROR)
1181                                         return (S_ERROR);
1182                         }
1183                         break;
1184 
1185                 case 'P':
1186                         DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c, optarg));
1187 
1188                         /*
1189                          * Multiple instances of this option may occur.  Each
1190                          * additional instance is effectively concatenated to
1191                          * the previous separated by a colon.
1192                          */
1193                         if (*optarg != '\0') {
1194                                 if ((ofl->ofl_depaudit =
1195                                     add_string(ofl->ofl_depaudit,
1196                                     optarg)) == (const char *)S_ERROR)
1197                                         return (S_ERROR);
1198                         }
1199                         break;
1200 
1201                 case 'r':
1202                         DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c, NULL));
1203                         rflag = TRUE;
1204                         break;
1205 
1206                 case 'R':
1207                         DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c, optarg));
1208 
1209                         /*
1210                          * Multiple instances of this option may occur.  Each
1211                          * additional instance is effectively concatenated to
1212                          * the previous separated by a colon.
1213                          */
1214                         if (*optarg != '\0') {
1215                                 if ((ofl->ofl_rpath =
1216                                     add_string(ofl->ofl_rpath,
1217                                     optarg)) == (const char *)S_ERROR)
1218                                         return (S_ERROR);
1219                         }
1220                         break;
1221 
1222                 case 's':
1223                         DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c, NULL));
1224                         sflag = TRUE;
1225                         break;
1226 
1227                 case 't':
1228                         DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c, NULL));
1229                         ofl->ofl_flags |= FLG_OF_NOWARN;
1230                         break;
1231 
1232                 case 'u':
1233                         DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c, optarg));
1234                         break;
1235 
1236                 case 'z':
1237                         DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c, optarg));
1238 
1239                         /*
1240                          * For specific help, print our usage message and exit
1241                          * immediately to ensure a 0 return code.
1242                          */
1243                         if (strncmp(optarg, MSG_ORIG(MSG_ARG_HELP),
1244                             MSG_ARG_HELP_SIZE) == 0) {
1245                                 usage_mesg(TRUE);
1246                                 exit(0);
1247                         }
1248 
1249                         /*
1250                          * For some options set a flag - further consistancy
1251                          * checks will be carried out in check_flags().
1252                          */
1253                         if ((strncmp(optarg, MSG_ORIG(MSG_ARG_LD32),
1254                             MSG_ARG_LD32_SIZE) == 0) ||
1255                             (strncmp(optarg, MSG_ORIG(MSG_ARG_LD64),
1256                             MSG_ARG_LD64_SIZE) == 0)) {
1257                                 if (createargv(ofl, usage) == S_ERROR)
1258                                         return (S_ERROR);
1259 
1260                         } else if (
1261                             strcmp(optarg, MSG_ORIG(MSG_ARG_DEFS)) == 0) {
1262                                 if (zdflag != SET_UNKNOWN)
1263                                         ld_eprintf(ofl, ERR_WARNING_NF,
1264                                             MSG_INTL(MSG_ARG_MTONCE),
1265                                             MSG_ORIG(MSG_ARG_ZDEFNODEF));
1266                                 else
1267                                         zdflag = SET_TRUE;
1268                                 ofl->ofl_guideflags |= FLG_OFG_NO_DEFS;
1269                         } else if (strcmp(optarg,
1270                             MSG_ORIG(MSG_ARG_NODEFS)) == 0) {
1271                                 if (zdflag != SET_UNKNOWN)
1272                                         ld_eprintf(ofl, ERR_WARNING_NF,
1273                                             MSG_INTL(MSG_ARG_MTONCE),
1274                                             MSG_ORIG(MSG_ARG_ZDEFNODEF));
1275                                 else
1276                                         zdflag = SET_FALSE;
1277                                 ofl->ofl_guideflags |= FLG_OFG_NO_DEFS;
1278                         } else if (strcmp(optarg,
1279                             MSG_ORIG(MSG_ARG_TEXT)) == 0) {
1280                                 if (ztflag &&
1281                                     (ztflag != MSG_ORIG(MSG_ARG_ZTEXT)))
1282                                         ld_eprintf(ofl, ERR_FATAL,
1283                                             MSG_INTL(MSG_ARG_INCOMP),
1284                                             MSG_ORIG(MSG_ARG_ZTEXT),
1285                                             ztflag);
1286                                 ztflag = MSG_ORIG(MSG_ARG_ZTEXT);
1287                         } else if (strcmp(optarg,
1288                             MSG_ORIG(MSG_ARG_TEXTOFF)) == 0) {
1289                                 if (ztflag &&
1290                                     (ztflag != MSG_ORIG(MSG_ARG_ZTEXTOFF)))
1291                                         ld_eprintf(ofl, ERR_FATAL,
1292                                             MSG_INTL(MSG_ARG_INCOMP),
1293                                             MSG_ORIG(MSG_ARG_ZTEXTOFF),
1294                                             ztflag);
1295                                 ztflag = MSG_ORIG(MSG_ARG_ZTEXTOFF);
1296                         } else if (strcmp(optarg,
1297                             MSG_ORIG(MSG_ARG_TEXTWARN)) == 0) {
1298                                 if (ztflag &&
1299                                     (ztflag != MSG_ORIG(MSG_ARG_ZTEXTWARN)))
1300                                         ld_eprintf(ofl, ERR_FATAL,
1301                                             MSG_INTL(MSG_ARG_INCOMP),
1302                                             MSG_ORIG(MSG_ARG_ZTEXTWARN),
1303                                             ztflag);
1304                                 ztflag = MSG_ORIG(MSG_ARG_ZTEXTWARN);
1305 
1306                         /*
1307                          * For other options simply set the ofl flags directly.
1308                          */
1309                         } else if (strcmp(optarg,
1310                             MSG_ORIG(MSG_ARG_RESCAN)) == 0) {
1311                                 ofl->ofl_flags1 |= FLG_OF1_RESCAN;
1312                         } else if (strcmp(optarg,
1313                             MSG_ORIG(MSG_ARG_ABSEXEC)) == 0) {
1314                                 ofl->ofl_flags1 |= FLG_OF1_ABSEXEC;
1315                         } else if (strcmp(optarg,
1316                             MSG_ORIG(MSG_ARG_LOADFLTR)) == 0) {
1317                                 zlflag = TRUE;
1318                         } else if (strcmp(optarg,
1319                             MSG_ORIG(MSG_ARG_NORELOC)) == 0) {
1320                                 ofl->ofl_dtflags_1 |= DF_1_NORELOC;
1321                         } else if (strcmp(optarg,
1322                             MSG_ORIG(MSG_ARG_NOVERSION)) == 0) {
1323                                 ofl->ofl_flags |= FLG_OF_NOVERSEC;
1324                         } else if (strcmp(optarg,
1325                             MSG_ORIG(MSG_ARG_MULDEFS)) == 0) {
1326                                 ofl->ofl_flags |= FLG_OF_MULDEFS;
1327                         } else if (strcmp(optarg,
1328                             MSG_ORIG(MSG_ARG_REDLOCSYM)) == 0) {
1329                                 ofl->ofl_flags |= FLG_OF_REDLSYM;
1330                         } else if (strcmp(optarg,
1331                             MSG_ORIG(MSG_ARG_INITFIRST)) == 0) {
1332                                 ofl->ofl_dtflags_1 |= DF_1_INITFIRST;
1333                         } else if (strcmp(optarg,
1334                             MSG_ORIG(MSG_ARG_NODELETE)) == 0) {
1335                                 ofl->ofl_dtflags_1 |= DF_1_NODELETE;
1336                         } else if (strcmp(optarg,
1337                             MSG_ORIG(MSG_ARG_NOPARTIAL)) == 0) {
1338                                 ofl->ofl_flags1 |= FLG_OF1_NOPARTI;
1339                         } else if (strcmp(optarg,
1340                             MSG_ORIG(MSG_ARG_NOOPEN)) == 0) {
1341                                 ofl->ofl_dtflags_1 |= DF_1_NOOPEN;
1342                         } else if (strcmp(optarg,
1343                             MSG_ORIG(MSG_ARG_NOW)) == 0) {
1344                                 ofl->ofl_dtflags_1 |= DF_1_NOW;
1345                                 ofl->ofl_dtflags |= DF_BIND_NOW;
1346                         } else if (strcmp(optarg,
1347                             MSG_ORIG(MSG_ARG_ORIGIN)) == 0) {
1348                                 ofl->ofl_dtflags_1 |= DF_1_ORIGIN;
1349                                 ofl->ofl_dtflags |= DF_ORIGIN;
1350                         } else if (strcmp(optarg,
1351                             MSG_ORIG(MSG_ARG_NODEFAULTLIB)) == 0) {
1352                                 ofl->ofl_dtflags_1 |= DF_1_NODEFLIB;
1353                         } else if (strcmp(optarg,
1354                             MSG_ORIG(MSG_ARG_NODUMP)) == 0) {
1355                                 ofl->ofl_dtflags_1 |= DF_1_NODUMP;
1356                         } else if (strcmp(optarg,
1357                             MSG_ORIG(MSG_ARG_ENDFILTEE)) == 0) {
1358                                 ofl->ofl_dtflags_1 |= DF_1_ENDFILTEE;
1359                         } else if (strcmp(optarg,
1360                             MSG_ORIG(MSG_ARG_VERBOSE)) == 0) {
1361                                 ofl->ofl_flags |= FLG_OF_VERBOSE;
1362                         } else if (strcmp(optarg,
1363                             MSG_ORIG(MSG_ARG_COMBRELOC)) == 0) {
1364                                 ofl->ofl_flags |= FLG_OF_COMREL;
1365                         } else if (strcmp(optarg,
1366                             MSG_ORIG(MSG_ARG_NOCOMBRELOC)) == 0) {
1367                                 ofl->ofl_flags |= FLG_OF_NOCOMREL;
1368                         } else if (strcmp(optarg,
1369                             MSG_ORIG(MSG_ARG_NOCOMPSTRTAB)) == 0) {
1370                                 ofl->ofl_flags1 |= FLG_OF1_NCSTTAB;
1371                         } else if (strcmp(optarg,
1372                             MSG_ORIG(MSG_ARG_NOINTERP)) == 0) {
1373                                 ofl->ofl_flags1 |= FLG_OF1_NOINTRP;
1374                         } else if (strcmp(optarg,
1375                             MSG_ORIG(MSG_ARG_INTERPOSE)) == 0) {
1376                                 zinflag = TRUE;
1377                         } else if (strcmp(optarg,
1378                             MSG_ORIG(MSG_ARG_IGNORE)) == 0) {
1379                                 ofl->ofl_flags1 |= FLG_OF1_IGNPRC;
1380                         } else if (strcmp(optarg,
1381                             MSG_ORIG(MSG_ARG_RELAXRELOC)) == 0) {
1382                                 ofl->ofl_flags1 |= FLG_OF1_RLXREL;
1383                         } else if (strcmp(optarg,
1384                             MSG_ORIG(MSG_ARG_NORELAXRELOC)) == 0) {
1385                                 ofl->ofl_flags1 |= FLG_OF1_NRLXREL;
1386                         } else if (strcmp(optarg,
1387                             MSG_ORIG(MSG_ARG_NOLDYNSYM)) == 0) {
1388                                 ofl->ofl_flags |= FLG_OF_NOLDYNSYM;
1389                         } else if (strcmp(optarg,
1390                             MSG_ORIG(MSG_ARG_GLOBAUDIT)) == 0) {
1391                                 ofl->ofl_dtflags_1 |= DF_1_GLOBAUDIT;
1392                         } else if (strcmp(optarg,
1393                             MSG_ORIG(MSG_ARG_NOSIGHANDLER)) == 0) {
1394                                 ofl->ofl_flags1 |= FLG_OF1_NOSGHND;
1395                         } else if (strcmp(optarg,
1396                             MSG_ORIG(MSG_ARG_SYMBOLCAP)) == 0) {
1397                                 ofl->ofl_flags |= FLG_OF_OTOSCAP;
1398 
1399                         /*
1400                          * Check archive group usage
1401                          *      -z rescan-start ... -z rescan-end
1402                          * to ensure they don't overlap and are well formed.
1403                          */
1404                         } else if (strcmp(optarg,
1405                             MSG_ORIG(MSG_ARG_RESCAN_START)) == 0) {
1406                                 if (ofl->ofl_ars_gsandx == 0) {
1407                                         ofl->ofl_ars_gsandx = ndx;
1408                                 } else if (ofl->ofl_ars_gsandx > 0) {
1409                                         /* Another group is still open */
1410                                         ld_eprintf(ofl, ERR_FATAL,
1411                                             MSG_INTL(MSG_ARG_AR_GRP_OLAP),
1412                                             MSG_INTL(MSG_MARG_AR_GRPS));
1413                                         /* Don't report cascading errors */
1414                                         ofl->ofl_ars_gsandx = -1;
1415                                 }
1416                         } else if (strcmp(optarg,
1417                             MSG_ORIG(MSG_ARG_RESCAN_END)) == 0) {
1418                                 if (ofl->ofl_ars_gsandx > 0) {
1419                                         ofl->ofl_ars_gsandx = 0;
1420                                 } else if (ofl->ofl_ars_gsandx == 0) {
1421                                         /* There was no matching begin */
1422                                         ld_eprintf(ofl, ERR_FATAL,
1423                                             MSG_INTL(MSG_ARG_AR_GRP_BAD),
1424                                             MSG_INTL(MSG_MARG_AR_GRP_END),
1425                                             MSG_INTL(MSG_MARG_AR_GRP_START));
1426                                         /* Don't report cascading errors */
1427                                         ofl->ofl_ars_gsandx = -1;
1428                                 }
1429 
1430                         /*
1431                          * If -z wrap is seen, enter the symbol to be wrapped
1432                          * into the wrap AVL tree.
1433                          */
1434                         } else if (strncmp(optarg, MSG_ORIG(MSG_ARG_WRAP),
1435                             MSG_ARG_WRAP_SIZE) == 0) {
1436                                 if (ld_wrap_enter(ofl,
1437                                     optarg + MSG_ARG_WRAP_SIZE) == NULL)
1438                                         return (S_ERROR);
1439                         } else if (strncmp(optarg, MSG_ORIG(MSG_ARG_ASLR),
1440                             MSG_ARG_ASLR_SIZE) == 0) {
1441                                 char *p = optarg + MSG_ARG_ASLR_SIZE;
1442                                 if (*p == '\0') {
1443                                         ofl->ofl_aslr = 1;
1444                                 } else if (*p == '=') {
1445                                         p++;
1446 
1447                                         if ((strcmp(p,
1448                                             MSG_ORIG(MSG_ARG_ENABLED)) == 0) ||
1449                                             (strcmp(p,
1450                                             MSG_ORIG(MSG_ARG_ENABLE)) == 0)) {
1451                                                 ofl->ofl_aslr = 1;
1452                                         } else if ((strcmp(p,
1453                                             MSG_ORIG(MSG_ARG_DISABLED)) == 0) ||
1454                                             (strcmp(p,
1455                                             MSG_ORIG(MSG_ARG_DISABLE)) == 0)) {
1456                                                 ofl->ofl_aslr = -1;
1457                                         } else {
1458                                                 ld_eprintf(ofl, ERR_FATAL,
1459                                                     MSG_INTL(MSG_ARG_ILLEGAL),
1460                                                     MSG_ORIG(MSG_ARG_ZASLR), p);
1461                                                 return (S_ERROR);
1462                                         }
1463                                 } else {
1464                                         ld_eprintf(ofl, ERR_FATAL,
1465                                             MSG_INTL(MSG_ARG_ILLEGAL),
1466                                             MSG_ORIG(MSG_ARG_Z), optarg);
1467                                         return (S_ERROR);
1468                                 }
1469                         } else if ((strncmp(optarg, MSG_ORIG(MSG_ARG_GUIDE),
1470                             MSG_ARG_GUIDE_SIZE) == 0) &&
1471                             ((optarg[MSG_ARG_GUIDE_SIZE] == '=') ||
1472                             (optarg[MSG_ARG_GUIDE_SIZE] == '\0'))) {
1473                                 if (!guidance_parse(ofl, optarg))
1474                                         return (S_ERROR);
1475                         } else if (strcmp(optarg,
1476                             MSG_ORIG(MSG_ARG_FATWARN)) == 0) {
1477                                 if (zfwflag  == SET_FALSE) {
1478                                         ld_eprintf(ofl, ERR_WARNING_NF,
1479                                             MSG_INTL(MSG_ARG_MTONCE),
1480                                             MSG_ORIG(MSG_ARG_ZFATWNOFATW));
1481                                 } else {
1482                                         zfwflag = SET_TRUE;
1483                                         ofl->ofl_flags |= FLG_OF_FATWARN;
1484                                 }
1485                         } else if (strcmp(optarg,
1486                             MSG_ORIG(MSG_ARG_NOFATWARN)) == 0) {
1487                                 if (zfwflag  == SET_TRUE)
1488                                         ld_eprintf(ofl, ERR_WARNING_NF,
1489                                             MSG_INTL(MSG_ARG_MTONCE),
1490                                             MSG_ORIG(MSG_ARG_ZFATWNOFATW));
1491                                 else
1492                                         zfwflag = SET_FALSE;
1493 
1494                         /*
1495                          * Process everything related to -z assert-deflib. This
1496                          * must be done in pass 1 because it gets used in pass
1497                          * 2.
1498                          */
1499                         } else if (strncmp(optarg, MSG_ORIG(MSG_ARG_ASSDEFLIB),
1500                             MSG_ARG_ASSDEFLIB_SIZE) == 0) {
1501                                 if (assdeflib_parse(ofl, optarg) != TRUE)
1502                                         return (S_ERROR);
1503                         /*
1504                          * The following options just need validation as they
1505                          * are interpreted on the second pass through the
1506                          * command line arguments.
1507                          */
1508                         } else if (
1509                             strncmp(optarg, MSG_ORIG(MSG_ARG_INITARRAY),
1510                             MSG_ARG_INITARRAY_SIZE) &&
1511                             strncmp(optarg, MSG_ORIG(MSG_ARG_FINIARRAY),
1512                             MSG_ARG_FINIARRAY_SIZE) &&
1513                             strncmp(optarg, MSG_ORIG(MSG_ARG_PREINITARRAY),
1514                             MSG_ARG_PREINITARRAY_SIZE) &&
1515                             strncmp(optarg, MSG_ORIG(MSG_ARG_RTLDINFO),
1516                             MSG_ARG_RTLDINFO_SIZE) &&
1517                             strncmp(optarg, MSG_ORIG(MSG_ARG_DTRACE),
1518                             MSG_ARG_DTRACE_SIZE) &&
1519                             strcmp(optarg, MSG_ORIG(MSG_ARG_ALLEXTRT)) &&
1520                             strcmp(optarg, MSG_ORIG(MSG_ARG_DFLEXTRT)) &&
1521                             strcmp(optarg, MSG_ORIG(MSG_ARG_DIRECT)) &&
1522                             strcmp(optarg, MSG_ORIG(MSG_ARG_NODIRECT)) &&
1523                             strcmp(optarg, MSG_ORIG(MSG_ARG_GROUPPERM)) &&
1524                             strcmp(optarg, MSG_ORIG(MSG_ARG_LAZYLOAD)) &&
1525                             strcmp(optarg, MSG_ORIG(MSG_ARG_NOGROUPPERM)) &&
1526                             strcmp(optarg, MSG_ORIG(MSG_ARG_NOLAZYLOAD)) &&
1527                             strcmp(optarg, MSG_ORIG(MSG_ARG_NODEFERRED)) &&
1528                             strcmp(optarg, MSG_ORIG(MSG_ARG_RECORD)) &&
1529                             strcmp(optarg, MSG_ORIG(MSG_ARG_ALTEXEC64)) &&
1530                             strcmp(optarg, MSG_ORIG(MSG_ARG_WEAKEXT)) &&
1531                             strncmp(optarg, MSG_ORIG(MSG_ARG_TARGET),
1532                             MSG_ARG_TARGET_SIZE) &&
1533                             strcmp(optarg, MSG_ORIG(MSG_ARG_RESCAN_NOW)) &&
1534                             strcmp(optarg, MSG_ORIG(MSG_ARG_DEFERRED))) {
1535                                 ld_eprintf(ofl, ERR_FATAL,
1536                                     MSG_INTL(MSG_ARG_ILLEGAL),
1537                                     MSG_ORIG(MSG_ARG_Z), optarg);
1538                         }
1539 
1540                         break;
1541 
1542                 case 'D':
1543                         /*
1544                          * If we have not yet read any input files go ahead
1545                          * and process any debugging options (this allows any
1546                          * argument processing, entrance criteria and library
1547                          * initialization to be displayed).  Otherwise, if an
1548                          * input file has been seen, skip interpretation until
1549                          * process_files (this allows debugging to be turned
1550                          * on and off around individual groups of files).
1551                          */
1552                         Dflag = 1;
1553                         if (ofl->ofl_objscnt == 0) {
1554                                 if (dbg_setup(ofl, optarg, 2) == 0)
1555                                         return (S_ERROR);
1556                         }
1557 
1558                         /*
1559                          * A diagnostic can only be provided after dbg_setup().
1560                          * As this is the first diagnostic that can be produced
1561                          * by ld(1), issue a title for timing and basic output.
1562                          */
1563                         if ((optitle == 0) && DBG_ENABLED) {
1564                                 optitle++;
1565                                 DBG_CALL(Dbg_basic_options(ofl->ofl_lml));
1566                         }
1567                         DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c, optarg));
1568                         break;
1569 
1570                 case 'B':
1571                         DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c, optarg));
1572                         if (strcmp(optarg, MSG_ORIG(MSG_ARG_DIRECT)) == 0) {
1573                                 if (Bdflag == SET_FALSE) {
1574                                         ld_eprintf(ofl, ERR_FATAL,
1575                                             MSG_INTL(MSG_ARG_INCOMP),
1576                                             MSG_ORIG(MSG_ARG_BNODIRECT),
1577                                             MSG_ORIG(MSG_ARG_BDIRECT));
1578                                 } else {
1579                                         Bdflag = SET_TRUE;
1580                                         ofl->ofl_guideflags |= FLG_OFG_NO_DB;
1581                                 }
1582                         } else if (strcmp(optarg,
1583                             MSG_ORIG(MSG_ARG_NODIRECT)) == 0) {
1584                                 if (Bdflag == SET_TRUE) {
1585                                         ld_eprintf(ofl, ERR_FATAL,
1586                                             MSG_INTL(MSG_ARG_INCOMP),
1587                                             MSG_ORIG(MSG_ARG_BDIRECT),
1588                                             MSG_ORIG(MSG_ARG_BNODIRECT));
1589                                 } else {
1590                                         Bdflag = SET_FALSE;
1591                                         ofl->ofl_guideflags |= FLG_OFG_NO_DB;
1592                                 }
1593                         } else if (strcmp(optarg,
1594                             MSG_ORIG(MSG_STR_SYMBOLIC)) == 0)
1595                                 Bsflag = TRUE;
1596                         else if (strcmp(optarg, MSG_ORIG(MSG_ARG_REDUCE)) == 0)
1597                                 ofl->ofl_flags |= FLG_OF_PROCRED;
1598                         else if (strcmp(optarg, MSG_ORIG(MSG_STR_LOCAL)) == 0)
1599                                 Blflag = TRUE;
1600                         else if (strcmp(optarg, MSG_ORIG(MSG_ARG_GROUP)) == 0)
1601                                 Bgflag = TRUE;
1602                         else if (strcmp(optarg,
1603                             MSG_ORIG(MSG_STR_ELIMINATE)) == 0)
1604                                 Beflag = TRUE;
1605                         else if (strcmp(optarg,
1606                             MSG_ORIG(MSG_ARG_TRANSLATOR)) == 0) {
1607                                 ld_eprintf(ofl, ERR_WARNING,
1608                                     MSG_INTL(MSG_ARG_UNSUPPORTED),
1609                                     MSG_ORIG(MSG_ARG_BTRANSLATOR));
1610                         } else if (strcmp(optarg,
1611                             MSG_ORIG(MSG_STR_LD_DYNAMIC)) &&
1612                             strcmp(optarg, MSG_ORIG(MSG_ARG_STATIC))) {
1613                                 ld_eprintf(ofl, ERR_FATAL,
1614                                     MSG_INTL(MSG_ARG_ILLEGAL),
1615                                     MSG_ORIG(MSG_ARG_CB), optarg);
1616                         }
1617                         break;
1618 
1619                 case 'G':
1620                         DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c, NULL));
1621                         Gflag = TRUE;
1622                         break;
1623 
1624                 case 'L':
1625                         DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c, optarg));
1626                         break;
1627 
1628                 case 'M':
1629                         DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c, optarg));
1630                         if (aplist_append(&(ofl->ofl_maps), optarg,
1631                             AL_CNT_OFL_MAPFILES) == NULL)
1632                                 return (S_ERROR);
1633                         break;
1634 
1635                 case 'N':
1636                         DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c, optarg));
1637                         break;
1638 
1639                 case 'Q':
1640                         DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c, optarg));
1641                         if ((optarg[0] == 'n') && (optarg[1] == '\0')) {
1642                                 if (Qflag != SET_UNKNOWN)
1643                                         ld_eprintf(ofl, ERR_WARNING_NF,
1644                                             MSG_INTL(MSG_ARG_MTONCE),
1645                                             MSG_ORIG(MSG_ARG_CQ));
1646                                 else
1647                                         Qflag = SET_FALSE;
1648                         } else if ((optarg[0] == 'y') && (optarg[1] == '\0')) {
1649                                 if (Qflag != SET_UNKNOWN)
1650                                         ld_eprintf(ofl, ERR_WARNING_NF,
1651                                             MSG_INTL(MSG_ARG_MTONCE),
1652                                             MSG_ORIG(MSG_ARG_CQ));
1653                                 else
1654                                         Qflag = SET_TRUE;
1655                         } else {
1656                                 ld_eprintf(ofl, ERR_FATAL,
1657                                     MSG_INTL(MSG_ARG_ILLEGAL),
1658                                     MSG_ORIG(MSG_ARG_CQ), optarg);
1659                         }
1660                         break;
1661 
1662                 case 'S':
1663                         DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c, optarg));
1664                         if (aplist_append(&lib_support, optarg,
1665                             AL_CNT_SUPPORT) == NULL)
1666                                 return (S_ERROR);
1667                         break;
1668 
1669                 case 'V':
1670                         DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c, NULL));
1671                         if (!Vflag)
1672                                 (void) fprintf(stderr, MSG_ORIG(MSG_STR_STRNL),
1673                                     ofl->ofl_sgsid);
1674                         Vflag = TRUE;
1675                         break;
1676 
1677                 case 'Y':
1678                         DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c, optarg));
1679                         if (strncmp(optarg, MSG_ORIG(MSG_ARG_LCOM), 2) == 0) {
1680                                 if (Llibdir)
1681                                         ld_eprintf(ofl, ERR_WARNING_NF,
1682                                             MSG_INTL(MSG_ARG_MTONCE),
1683                                             MSG_ORIG(MSG_ARG_CYL));
1684                                 else
1685                                         Llibdir = optarg + 2;
1686                         } else if (strncmp(optarg,
1687                             MSG_ORIG(MSG_ARG_UCOM), 2) == 0) {
1688                                 if (Ulibdir)
1689                                         ld_eprintf(ofl, ERR_WARNING_NF,
1690                                             MSG_INTL(MSG_ARG_MTONCE),
1691                                             MSG_ORIG(MSG_ARG_CYU));
1692                                 else
1693                                         Ulibdir = optarg + 2;
1694                         } else if (strncmp(optarg,
1695                             MSG_ORIG(MSG_ARG_PCOM), 2) == 0) {
1696                                 if (Plibpath)
1697                                         ld_eprintf(ofl, ERR_WARNING_NF,
1698                                             MSG_INTL(MSG_ARG_MTONCE),
1699                                             MSG_ORIG(MSG_ARG_CYP));
1700                                 else
1701                                         Plibpath = optarg + 2;
1702                         } else {
1703                                 ld_eprintf(ofl, ERR_FATAL,
1704                                     MSG_INTL(MSG_ARG_ILLEGAL),
1705                                     MSG_ORIG(MSG_ARG_CY), optarg);
1706                         }
1707                         break;
1708 
1709                 case '?':
1710                         DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c, NULL));
1711                         /*
1712                          * If the option character is '-', we're looking at a
1713                          * long option which couldn't be translated, display a
1714                          * more useful error.
1715                          */
1716                         if (optopt == '-') {
1717                                 eprintf(ofl->ofl_lml, ERR_FATAL,
1718                                     MSG_INTL(MSG_ARG_LONG_UNKNOWN),
1719                                     argv[optind-1]);
1720                         } else {
1721                                 eprintf(ofl->ofl_lml, ERR_FATAL,
1722                                     MSG_INTL(MSG_ARG_UNKNOWN), optopt);
1723                         }
1724                         (*usage)++;
1725                         break;
1726 
1727                 default:
1728                         break;
1729                 }
1730 
1731                 /*
1732                  * Update the argument index for the next getopt() iteration.
1733                  */
1734                 ndx = optind;
1735         }
1736         return (1);
1737 }
1738 
1739 /*
1740  * Parsing options pass2 for
1741  */
1742 static uintptr_t
1743 parseopt_pass2(Ofl_desc *ofl, int argc, char **argv)
1744 {
1745         int     c, ndx = optind;
1746 
1747         while ((c = ld_getopt(ofl->ofl_lml, ndx, argc, argv)) != -1) {
1748                 Ifl_desc        *ifl;
1749                 Sym_desc        *sdp;
1750 
1751                 switch (c) {
1752                         case 'l':
1753                                 DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c,
1754                                     optarg));
1755                                 if (ld_find_library(optarg, ofl) == S_ERROR)
1756                                         return (S_ERROR);
1757                                 break;
1758                         case 'B':
1759                                 DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c,
1760                                     optarg));
1761                                 if (strcmp(optarg,
1762                                     MSG_ORIG(MSG_STR_LD_DYNAMIC)) == 0) {
1763                                         if (ofl->ofl_flags & FLG_OF_DYNAMIC)
1764                                                 ofl->ofl_flags |=
1765                                                     FLG_OF_DYNLIBS;
1766                                         else {
1767                                                 ld_eprintf(ofl, ERR_FATAL,
1768                                                     MSG_INTL(MSG_ARG_ST_INCOMP),
1769                                                     MSG_ORIG(MSG_ARG_BDYNAMIC));
1770                                         }
1771                                 } else if (strcmp(optarg,
1772                                     MSG_ORIG(MSG_ARG_STATIC)) == 0)
1773                                         ofl->ofl_flags &= ~FLG_OF_DYNLIBS;
1774                                 break;
1775                         case 'L':
1776                                 DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c,
1777                                     optarg));
1778                                 if (ld_add_libdir(ofl, optarg) == S_ERROR)
1779                                         return (S_ERROR);
1780                                 break;
1781                         case 'N':
1782                                 DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c,
1783                                     optarg));
1784                                 /*
1785                                  * Record DT_NEEDED string
1786                                  */
1787                                 if (!(ofl->ofl_flags & FLG_OF_DYNAMIC))
1788                                         ld_eprintf(ofl, ERR_FATAL,
1789                                             MSG_INTL(MSG_ARG_ST_INCOMP),
1790                                             MSG_ORIG(MSG_ARG_CN));
1791                                 if (((ifl = libld_calloc(1,
1792                                     sizeof (Ifl_desc))) == NULL) ||
1793                                     (aplist_append(&ofl->ofl_sos, ifl,
1794                                     AL_CNT_OFL_LIBS) == NULL))
1795                                         return (S_ERROR);
1796 
1797                                 ifl->ifl_name = MSG_INTL(MSG_STR_COMMAND);
1798                                 ifl->ifl_soname = optarg;
1799                                 ifl->ifl_flags = (FLG_IF_NEEDSTR |
1800                                     FLG_IF_FILEREF | FLG_IF_DEPREQD);
1801 
1802                                 break;
1803                         case 'D':
1804                                 DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c,
1805                                     optarg));
1806                                 (void) dbg_setup(ofl, optarg, 3);
1807                                 break;
1808                         case 'u':
1809                                 DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c,
1810                                     optarg));
1811                                 if (ld_sym_add_u(optarg, ofl,
1812                                     MSG_STR_COMMAND) == (Sym_desc *)S_ERROR)
1813                                         return (S_ERROR);
1814                                 break;
1815                         case 'z':
1816                                 DBG_CALL(Dbg_args_option(ofl->ofl_lml, ndx, c,
1817                                     optarg));
1818                                 if ((strncmp(optarg, MSG_ORIG(MSG_ARG_LD32),
1819                                     MSG_ARG_LD32_SIZE) == 0) ||
1820                                     (strncmp(optarg, MSG_ORIG(MSG_ARG_LD64),
1821                                     MSG_ARG_LD64_SIZE) == 0)) {
1822                                         if (createargv(ofl, 0) == S_ERROR)
1823                                                 return (S_ERROR);
1824                                 } else if (strcmp(optarg,
1825                                     MSG_ORIG(MSG_ARG_ALLEXTRT)) == 0) {
1826                                         ofl->ofl_flags1 |= FLG_OF1_ALLEXRT;
1827                                         ofl->ofl_flags1 &= ~FLG_OF1_WEAKEXT;
1828                                 } else if (strcmp(optarg,
1829                                     MSG_ORIG(MSG_ARG_WEAKEXT)) == 0) {
1830                                         ofl->ofl_flags1 |= FLG_OF1_WEAKEXT;
1831                                         ofl->ofl_flags1 &= ~FLG_OF1_ALLEXRT;
1832                                 } else if (strcmp(optarg,
1833                                     MSG_ORIG(MSG_ARG_DFLEXTRT)) == 0) {
1834                                         ofl->ofl_flags1 &=
1835                                             ~(FLG_OF1_ALLEXRT |
1836                                             FLG_OF1_WEAKEXT);
1837                                 } else if (strcmp(optarg,
1838                                     MSG_ORIG(MSG_ARG_DIRECT)) == 0) {
1839                                         ofl->ofl_flags1 |= FLG_OF1_ZDIRECT;
1840                                         ofl->ofl_guideflags |= FLG_OFG_NO_DB;
1841                                 } else if (strcmp(optarg,
1842                                     MSG_ORIG(MSG_ARG_NODIRECT)) == 0) {
1843                                         ofl->ofl_flags1 &= ~FLG_OF1_ZDIRECT;
1844                                         ofl->ofl_guideflags |= FLG_OFG_NO_DB;
1845                                 } else if (strcmp(optarg,
1846                                     MSG_ORIG(MSG_ARG_IGNORE)) == 0) {
1847                                         ofl->ofl_flags1 |= FLG_OF1_IGNORE;
1848                                 } else if (strcmp(optarg,
1849                                     MSG_ORIG(MSG_ARG_RECORD)) == 0) {
1850                                         ofl->ofl_flags1 &= ~FLG_OF1_IGNORE;
1851                                 } else if (strcmp(optarg,
1852                                     MSG_ORIG(MSG_ARG_LAZYLOAD)) == 0) {
1853                                         ofl->ofl_flags1 |= FLG_OF1_LAZYLD;
1854                                         ofl->ofl_guideflags |= FLG_OFG_NO_LAZY;
1855                                 } else if (strcmp(optarg,
1856                                     MSG_ORIG(MSG_ARG_NOLAZYLOAD)) == 0) {
1857                                         ofl->ofl_flags1 &= ~ FLG_OF1_LAZYLD;
1858                                         ofl->ofl_guideflags |= FLG_OFG_NO_LAZY;
1859                                 } else if (strcmp(optarg,
1860                                     MSG_ORIG(MSG_ARG_GROUPPERM)) == 0) {
1861                                         ofl->ofl_flags1 |= FLG_OF1_GRPPRM;
1862                                 } else if (strcmp(optarg,
1863                                     MSG_ORIG(MSG_ARG_NOGROUPPERM)) == 0) {
1864                                         ofl->ofl_flags1 &= ~FLG_OF1_GRPPRM;
1865                                 } else if (strncmp(optarg,
1866                                     MSG_ORIG(MSG_ARG_INITARRAY),
1867                                     MSG_ARG_INITARRAY_SIZE) == 0) {
1868                                         if (((sdp = ld_sym_add_u(optarg +
1869                                             MSG_ARG_INITARRAY_SIZE, ofl,
1870                                             MSG_STR_COMMAND)) ==
1871                                             (Sym_desc *)S_ERROR) ||
1872                                             (aplist_append(&ofl->ofl_initarray,
1873                                             sdp, AL_CNT_OFL_ARRAYS) == NULL))
1874                                                 return (S_ERROR);
1875                                 } else if (strncmp(optarg,
1876                                     MSG_ORIG(MSG_ARG_FINIARRAY),
1877                                     MSG_ARG_FINIARRAY_SIZE) == 0) {
1878                                         if (((sdp = ld_sym_add_u(optarg +
1879                                             MSG_ARG_FINIARRAY_SIZE, ofl,
1880                                             MSG_STR_COMMAND)) ==
1881                                             (Sym_desc *)S_ERROR) ||
1882                                             (aplist_append(&ofl->ofl_finiarray,
1883                                             sdp, AL_CNT_OFL_ARRAYS) == NULL))
1884                                                 return (S_ERROR);
1885                                 } else if (strncmp(optarg,
1886                                     MSG_ORIG(MSG_ARG_PREINITARRAY),
1887                                     MSG_ARG_PREINITARRAY_SIZE) == 0) {
1888                                         if (((sdp = ld_sym_add_u(optarg +
1889                                             MSG_ARG_PREINITARRAY_SIZE, ofl,
1890                                             MSG_STR_COMMAND)) ==
1891                                             (Sym_desc *)S_ERROR) ||
1892                                             (aplist_append(&ofl->ofl_preiarray,
1893                                             sdp, AL_CNT_OFL_ARRAYS) == NULL))
1894                                                 return (S_ERROR);
1895                                 } else if (strncmp(optarg,
1896                                     MSG_ORIG(MSG_ARG_RTLDINFO),
1897                                     MSG_ARG_RTLDINFO_SIZE) == 0) {
1898                                         if (((sdp = ld_sym_add_u(optarg +
1899                                             MSG_ARG_RTLDINFO_SIZE, ofl,
1900                                             MSG_STR_COMMAND)) ==
1901                                             (Sym_desc *)S_ERROR) ||
1902                                             (aplist_append(&ofl->ofl_rtldinfo,
1903                                             sdp, AL_CNT_OFL_ARRAYS) == NULL))
1904                                                 return (S_ERROR);
1905                                 } else if (strncmp(optarg,
1906                                     MSG_ORIG(MSG_ARG_DTRACE),
1907                                     MSG_ARG_DTRACE_SIZE) == 0) {
1908                                         if ((sdp = ld_sym_add_u(optarg +
1909                                             MSG_ARG_DTRACE_SIZE, ofl,
1910                                             MSG_STR_COMMAND)) ==
1911                                             (Sym_desc *)S_ERROR)
1912                                                 return (S_ERROR);
1913                                         ofl->ofl_dtracesym = sdp;
1914                                 } else if (strcmp(optarg,
1915                                     MSG_ORIG(MSG_ARG_RESCAN_NOW)) == 0) {
1916                                         if (ld_rescan_archives(ofl, 0, ndx) ==
1917                                             S_ERROR)
1918                                                 return (S_ERROR);
1919                                 } else if (strcmp(optarg,
1920                                     MSG_ORIG(MSG_ARG_RESCAN_START)) == 0) {
1921                                         ofl->ofl_ars_gsndx = ofl->ofl_arscnt;
1922                                         ofl->ofl_ars_gsandx = ndx;
1923                                 } else if (strcmp(optarg,
1924                                     MSG_ORIG(MSG_ARG_RESCAN_END)) == 0) {
1925                                         if (ld_rescan_archives(ofl, 1, ndx) ==
1926                                             S_ERROR)
1927                                                 return (S_ERROR);
1928                                 } else if (strcmp(optarg,
1929                                     MSG_ORIG(MSG_ARG_DEFERRED)) == 0) {
1930                                         ofl->ofl_flags1 |= FLG_OF1_DEFERRED;
1931                                 } else if (strcmp(optarg,
1932                                     MSG_ORIG(MSG_ARG_NODEFERRED)) == 0) {
1933                                         ofl->ofl_flags1 &= ~FLG_OF1_DEFERRED;
1934                                 }
1935                         default:
1936                                 break;
1937                 }
1938 
1939                 /*
1940                  * Update the argument index for the next getopt() iteration.
1941                  */
1942                 ndx = optind;
1943         }
1944         return (1);
1945 }
1946 
1947 /*
1948  *
1949  * Pass 1 -- process_flags: collects all options and sets flags
1950  */
1951 static uintptr_t
1952 process_flags_com(Ofl_desc *ofl, int argc, char **argv, int *usage)
1953 {
1954         for (; optind < argc; optind++) {
1955                 /*
1956                  * If we detect some more options return to getopt().
1957                  * Checking argv[optind][1] against null prevents a forever
1958                  * loop if an unadorned `-' argument is passed to us.
1959                  */
1960                 while ((optind < argc) && (argv[optind][0] == '-')) {
1961                         if (argv[optind][1] != '\0') {
1962                                 if (parseopt_pass1(ofl, argc, argv,
1963                                     usage) == S_ERROR)
1964                                         return (S_ERROR);
1965                         } else if (++optind < argc)
1966                                 continue;
1967                 }
1968                 if (optind >= argc)
1969                         break;
1970                 ofl->ofl_objscnt++;
1971         }
1972 
1973         /* Did an unterminated archive group run off the end? */
1974         if (ofl->ofl_ars_gsandx > 0) {
1975                 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_ARG_AR_GRP_BAD),
1976                     MSG_INTL(MSG_MARG_AR_GRP_START),
1977                     MSG_INTL(MSG_MARG_AR_GRP_END));
1978                 return (S_ERROR);
1979         }
1980 
1981         return (1);
1982 }
1983 
1984 uintptr_t
1985 ld_process_flags(Ofl_desc *ofl, int argc, char **argv)
1986 {
1987         int     usage = 0;      /* Collect all argument errors before exit */
1988 
1989         if (argc < 2) {
1990                 usage_mesg(FALSE);
1991                 return (S_ERROR);
1992         }
1993 
1994         /*
1995          * Option handling
1996          */
1997         opterr = 0;
1998         optind = 1;
1999         if (process_flags_com(ofl, argc, argv, &usage) == S_ERROR)
2000                 return (S_ERROR);
2001 
2002         /*
2003          * Having parsed everything, did we have any usage errors.
2004          */
2005         if (usage) {
2006                 eprintf(ofl->ofl_lml, ERR_FATAL, MSG_INTL(MSG_ARG_USEHELP));
2007                 return (S_ERROR);
2008         }
2009 
2010         return (check_flags(ofl, argc));
2011 }
2012 
2013 /*
2014  * Pass 2 -- process_files: skips the flags collected in pass 1 and processes
2015  * files.
2016  */
2017 static uintptr_t
2018 process_files_com(Ofl_desc *ofl, int argc, char **argv)
2019 {
2020         for (; optind < argc; optind++) {
2021                 int             fd;
2022                 uintptr_t       open_ret;
2023                 char            *path;
2024                 Rej_desc        rej = { 0 };
2025 
2026                 /*
2027                  * If we detect some more options return to getopt().
2028                  * Checking argv[optind][1] against null prevents a forever
2029                  * loop if an unadorned `-' argument is passed to us.
2030                  */
2031                 while ((optind < argc) && (argv[optind][0] == '-')) {
2032                         if (argv[optind][1] != '\0') {
2033                                 if (parseopt_pass2(ofl, argc, argv) == S_ERROR)
2034                                         return (S_ERROR);
2035                         } else if (++optind < argc)
2036                                 continue;
2037                 }
2038                 if (optind >= argc)
2039                         break;
2040 
2041                 path = argv[optind];
2042                 if ((fd = open(path, O_RDONLY)) == -1) {
2043                         int err = errno;
2044 
2045                         ld_eprintf(ofl, ERR_FATAL,
2046                             MSG_INTL(MSG_SYS_OPEN), path, strerror(err));
2047                         continue;
2048                 }
2049 
2050                 DBG_CALL(Dbg_args_file(ofl->ofl_lml, optind, path));
2051 
2052                 open_ret = ld_process_open(path, path, &fd, ofl,
2053                     (FLG_IF_CMDLINE | FLG_IF_NEEDED), &rej, NULL);
2054                 if (fd != -1)
2055                         (void) close(fd);
2056                 if (open_ret == S_ERROR)
2057                         return (S_ERROR);
2058 
2059                 /*
2060                  * Check for mismatched input.
2061                  */
2062                 if (rej.rej_type) {
2063                         Conv_reject_desc_buf_t rej_buf;
2064 
2065                         ld_eprintf(ofl, ERR_FATAL,
2066                             MSG_INTL(reject[rej.rej_type]),
2067                             rej.rej_name ? rej.rej_name :
2068                             MSG_INTL(MSG_STR_UNKNOWN),
2069                             conv_reject_desc(&rej, &rej_buf,
2070                             ld_targ.t_m.m_mach));
2071                         return (1);
2072                 }
2073         }
2074         return (1);
2075 }
2076 
2077 uintptr_t
2078 ld_process_files(Ofl_desc *ofl, int argc, char **argv)
2079 {
2080         DBG_CALL(Dbg_basic_files(ofl->ofl_lml));
2081 
2082         /*
2083          * Process command line files (taking into account any applicable
2084          * preceding flags).  Return if any fatal errors have occurred.
2085          */
2086         opterr = 0;
2087         optind = 1;
2088         if (process_files_com(ofl, argc, argv) == S_ERROR)
2089                 return (S_ERROR);
2090         if (ofl->ofl_flags & FLG_OF_FATAL)
2091                 return (1);
2092 
2093         /*
2094          * Guidance: Use -B direct/nodirect or -z direct/nodirect.
2095          *
2096          * This is a backstop for the case where the link had no dependencies.
2097          * Otherwise, it will get caught by ld_process_ifl(). We need both,
2098          * because -z direct is positional, and its value at the time where
2099          * the first dependency is seen might be different than it is now.
2100          */
2101         if ((ofl->ofl_flags & FLG_OF_DYNAMIC) &&
2102             OFL_GUIDANCE(ofl, FLG_OFG_NO_DB)) {
2103                 ld_eprintf(ofl, ERR_GUIDANCE, MSG_INTL(MSG_GUIDE_DIRECT));
2104                 ofl->ofl_guideflags |= FLG_OFG_NO_DB;
2105         }
2106 
2107         /*
2108          * Now that all command line files have been processed see if there are
2109          * any additional `needed' shared object dependencies.
2110          */
2111         if (ofl->ofl_soneed)
2112                 if (ld_finish_libs(ofl) == S_ERROR)
2113                         return (S_ERROR);
2114 
2115         /*
2116          * If rescanning archives is enabled, do so now to determine whether
2117          * there might still be members extracted to satisfy references from any
2118          * explicit objects.  Continue until no new objects are extracted.  Note
2119          * that this pass is carried out *after* processing any implicit objects
2120          * (above) as they may already have resolved any undefined references
2121          * from any explicit dependencies.
2122          */
2123         if (ofl->ofl_flags1 & FLG_OF1_RESCAN) {
2124                 if (ld_rescan_archives(ofl, 0, argc) == S_ERROR)
2125                         return (S_ERROR);
2126                 if (ofl->ofl_flags & FLG_OF_FATAL)
2127                         return (1);
2128         }
2129 
2130         /*
2131          * If debugging, provide statistics on each archives extraction, or flag
2132          * any archive that has provided no members.  Note that this could be a
2133          * nice place to free up much of the archive infrastructure, as we've
2134          * extracted any members we need.  However, as we presently don't free
2135          * anything under ld(1) there's not much point in proceeding further.
2136          */
2137         DBG_CALL(Dbg_statistics_ar(ofl));
2138 
2139         /*
2140          * If any version definitions have been established, either via input
2141          * from a mapfile or from the input relocatable objects, make sure any
2142          * version dependencies are satisfied, and version symbols created.
2143          */
2144         if (ofl->ofl_verdesc)
2145                 if (ld_vers_check_defs(ofl) == S_ERROR)
2146                         return (S_ERROR);
2147 
2148         /*
2149          * If input section ordering was specified within some segment
2150          * using a mapfile, verify that the expected sections were seen.
2151          */
2152         if (ofl->ofl_flags & FLG_OF_IS_ORDER)
2153                 ld_ent_check(ofl);
2154 
2155         return (1);
2156 }
2157 
2158 uintptr_t
2159 ld_init_strings(Ofl_desc *ofl)
2160 {
2161         uint_t  stflags;
2162 
2163         if (ofl->ofl_flags1 & FLG_OF1_NCSTTAB)
2164                 stflags = 0;
2165         else
2166                 stflags = FLG_STNEW_COMPRESS;
2167 
2168         if (((ofl->ofl_shdrsttab = st_new(stflags)) == NULL) ||
2169             ((ofl->ofl_strtab = st_new(stflags)) == NULL) ||
2170             ((ofl->ofl_dynstrtab = st_new(stflags)) == NULL))
2171                 return (S_ERROR);
2172 
2173         return (0);
2174 }