9031 sgs/libld: comparison between pointer and zero character constant

[unleashed.git] / usr / src / cmd / sgs / libld / common / map_core.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 *      Copyright (c) 1988 AT&T
 *        All Rights Reserved
 *
 * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * Map file parsing (Shared Core Code).
 */
#include        <fcntl.h>
#include        <stdio.h>
#include        <unistd.h>
#include        <sys/stat.h>
#include        <errno.h>
#include        <limits.h>
#include        <dirent.h>
#include        <ctype.h>
#include        <debug.h>
#include        "msg.h"
#include        "_libld.h"
#include        "_map.h"

/*
 * There are two styles of mapfile supported by the link-editor:
 *
 * 1)   The original System V defined syntax, as augmented at Sun
 *      from Solaris 2.0 through Solaris 10. This style is also known
 *      as version 1.
 *
 * 2)   A newer syntax, currently at version 2.
 *
 * The original syntax uses special characters (=, :, -, |, etc) as
 * operators to indicate the operation being specified. Over the years,
 * this syntax has been problematic:
 *
 * 1)   Too cryptic: It's hard for people to remember which character
 *      means what.
 *
 * 2)   Limited expansion potential: There only a few special characters
 *      available on the keyboard for new features, and it is difficult to
 *      add options to existing ones.
 *
 * Adding new features into this framework (2) have the effect of
 * making the syntax even more cryptic (1). The newer syntax addresses
 * these issues by moving to an extendible identifier based syntax that
 * allows new features to be added without complicating old ones.
 *
 * The new syntax uses the following terminology:
 *
 * -    Control directives are the directives that start with a '$'.
 *      They control how the mapfile is interpreted. We use the 'cdir_'
 *      prefix on functions and variables related to these directives.
 *
 * -    Conditional Expressions are the expressions found in $if and $elif
 *      control directives. They evaluate to boolean true/false values.
 *      We use the 'cexp_' prefix for functions and variables related to
 *      these expressions.
 *
 * -    Regular Directives are names (SYMBOL, VERSION, etc) that convey
 *      directions to the link-editor for building the output object.
 *
 * This file contains core code used by both mapfile styles: File management,
 * lexical analysis, and other shared core functionality. It also contains
 * the code for control directives, as they are intrinsically part of
 * lexical analysis --- this is disabled when processing Sysv mapfiles.
 */

/*
 * We use a stack of cdir_level_t structs to manage $if/$elif/$else/$endif
 * processing. At each level, we keep track of the information needed to
 * determine whether or not to process nested input lines or skip them,
 * along with information needed to report errors.
 */
typedef struct {
        Lineno          cdl_if_lineno;  /* Line number of opening $if */
        Lineno          cdl_else_lineno; /* 0, or line on which $else seen */
        int             cdl_done;       /* True if no longer accepts input */
        int             cdl_pass;       /* True if currently accepting input */
} cdir_level_t;

/* Operators in the expressions accepted by $if/$elif */
typedef enum {
        CEXP_OP_NONE,           /* Not an operator */
        CEXP_OP_AND,            /* && */
        CEXP_OP_OR,             /* || */
        CEXP_OP_NEG,            /* ! */
        CEXP_OP_OPAR,           /* ( */
        CEXP_OP_CPAR            /* ) */
} cexp_op_t;

/*
 * Type of conditional expression identifier AVL tree nodes
 */
typedef struct cexp_name_node {
        avl_node_t      ceid_avlnode;   /* AVL book-keeping */
        const char      *ceid_name;     /* boolean identifier name */
} cexp_id_node_t;


/*
 * Declare a "stack" type, containing a pointer to data, a count of
 * allocated, and currently used items in the stack. The data type
 * is specified as the _type argument.
 */
#define STACK(_type) \
        struct { \
                _type   *stk_s;         /* Stack array */ \
                size_t  stk_n;          /* Current stack depth */ \
                size_t  stk_n_alloc;    /* # of elements pointed at by s */ \
        }

/*
 * The following type represents a "generic" stack, where the data
 * type is (void). This type is never instantiated. However, it has
 * the same struct layout as any other STACK(), and is therefore a good
 * generic type that can be used for stack_resize().
 */
typedef STACK(void) generic_stack_t;

/*
 * Ensure that the stack has enough room to push one more item
 */
#define STACK_RESERVE(_stack, _n_default) \
        (((_stack).stk_n < (_stack).stk_n_alloc) || \
        stack_resize((generic_stack_t *)&(_stack).stk_s, _n_default, \
        sizeof (*(_stack).stk_s)))

/*
 * Reset a stack to empty.
 */
#define STACK_RESET(_stack) (_stack).stk_n = 0;

/*
 * True if stack is empty, False otherwise.
 */
#define STACK_IS_EMPTY(_stack) ((_stack).stk_n == 0)

/*
 * Push a value onto a stack. Caller must ensure that stack has room.
 * This macro is intended to be used as the LHS of an assignment, the
 * RHS of which is the value:
 *
 *      STACK_PUSH(stack) = value;
 */
#define STACK_PUSH(_stack) (_stack).stk_s[(_stack).stk_n++]

/*
 * Pop a value off a stack.  Caller must ensure
 * that stack is not empty.
 */
#define STACK_POP(_stack) ((_stack).stk_s[--(_stack).stk_n])

/*
 * Access top element on stack without popping. Caller must ensure
 * that stack is not empty.
 */
#define STACK_TOP(_stack) (((_stack).stk_s)[(_stack).stk_n - 1])

/*
 * Initial sizes used for the stacks: The stacks are allocated on demand
 * to these sizes, and then doubled as necessary until they are large enough.
 *
 * The ideal size would be large enough that only a single allocation
 * occurs, and our defaults should generally have that effect. However,
 * in doing so, we run the risk of a latent error in the resize code going
 * undetected until triggered by a large task in the field. For this reason,
 * we set the sizes to the smallest size possible when compiled for debug.
 */
#ifdef DEBUG
#define CDIR_STACK_INIT         1
#define CEXP_OP_STACK_INIT      1
#define CEXP_VAL_STACK_INIT     1
#else
#define CDIR_STACK_INIT         16
#define CEXP_OP_STACK_INIT      8
#define CEXP_VAL_STACK_INIT     (CEXP_OP_STACK_INIT * 2) /* 2 vals per binop */
#endif


/*
 * Persistent state maintained by map module in between calls.
 *
 * This is kept as static file scope data, because it is only used
 * when libld is called by ld, and not by rtld. If that should change,
 * the code is designed so that it can become reentrant easily:
 *
 * -    Add a pointer to the output descriptor to a structure of this type,
 *      allocated dynamically on the first call to ld_map_parse().
 * -    Change all references to lms to instead reference the pointer in
 *      the output descriptor.
 *
 * Until then, it is simpler not to expose these details.
 */
typedef struct {
        int     lms_cdir_valid; /* Allow control dir. on entry to gettoken() */
        STACK(cdir_level_t)     lms_cdir_stack; /* Conditional input level */
        STACK(cexp_op_t)        lms_cexp_op_stack; /* Cond. expr operators */
        STACK(uchar_t)          lms_cexp_val_stack; /* Cond. expr values */
        avl_tree_t              *lms_cexp_id;
} ld_map_state_t;
static ld_map_state_t lms;


/*
 * Version 1 (SysV) syntax dispatch table for ld_map_gettoken(). For each
 * of the 7-bit ASCII characters, determine how the lexical analyzer
 * should behave.
 *
 * This table must be kept in sync with tkid_attr[] below.
 *
 * Identifier Note:
 * The Linker and Libraries Guide states that the original syntax uses
 * C identifier rules, allowing '.' to be treated as a letter. However,
 * the implementation is considerably looser than that: Any character
 * with an ASCII code (0-127) which is printable and not used to start
 * another token is allowed to start an identifier, and they are terminated
 * by any of: space, double quote, tab, newline, ':', ';', '=', or '#'.
 * The original code has been replaced, but this table encodes the same
 * rules, to ensure backward compatibility.
 */
static const mf_tokdisp_t gettok_dispatch_v1 = {
        TK_OP_EOF,                      /* 0 - NUL */
        TK_OP_ILLCHR,                   /* 1 - SOH */
        TK_OP_ILLCHR,                   /* 2 - STX */
        TK_OP_ILLCHR,                   /* 3 - ETX */
        TK_OP_ILLCHR,                   /* 4 - EOT */
        TK_OP_ILLCHR,                   /* 5 - ENQ */
        TK_OP_ILLCHR,                   /* 6 - ACK */
        TK_OP_ILLCHR,                   /* 7 - BEL */
        TK_OP_ILLCHR,                   /* 8 - BS */
        TK_OP_WS,                       /* 9 - HT */
        TK_OP_NL,                       /* 10 - NL */
        TK_OP_WS,                       /* 11 - VT */
        TK_OP_WS,                       /* 12 - FF */
        TK_OP_WS,                       /* 13 - CR */
        TK_OP_ILLCHR,                   /* 14 - SO */
        TK_OP_ILLCHR,                   /* 15 - SI */
        TK_OP_ILLCHR,                   /* 16 - DLE */
        TK_OP_ILLCHR,                   /* 17 - DC1 */
        TK_OP_ILLCHR,                   /* 18 - DC2 */
        TK_OP_ILLCHR,                   /* 19 - DC3 */
        TK_OP_ILLCHR,                   /* 20 - DC4 */
        TK_OP_ILLCHR,                   /* 21 - NAK */
        TK_OP_ILLCHR,                   /* 22 - SYN */
        TK_OP_ILLCHR,                   /* 23 - ETB */
        TK_OP_ILLCHR,                   /* 24 - CAN */
        TK_OP_ILLCHR,                   /* 25 - EM */
        TK_OP_ILLCHR,                   /* 26 - SUB */
        TK_OP_ILLCHR,                   /* 27 - ESC */
        TK_OP_ILLCHR,                   /* 28 - FS */
        TK_OP_ILLCHR,                   /* 29 - GS */
        TK_OP_ILLCHR,                   /* 30 - RS */
        TK_OP_ILLCHR,                   /* 31 - US */
        TK_OP_WS,                       /* 32 - SP */
        TK_OP_ID,                       /* 33 - ! */
        TK_OP_SIMQUOTE,                 /* 34 - " */
        TK_OP_CMT,                      /* 35 - # */
        TK_OP_ID,                       /* 36 - $ */
        TK_OP_ID,                       /* 37 - % */
        TK_OP_ID,                       /* 38 - & */
        TK_OP_ID,                       /* 39 - ' */
        TK_OP_ID,                       /* 40 - ( */
        TK_OP_ID,                       /* 41 - ) */
        TK_OP_ID,                       /* 42 - * */
        TK_OP_ID,                       /* 43 - + */
        TK_OP_ID,                       /* 44 - , */
        TK_DASH,                        /* 45 - - */
        TK_OP_ID,                       /* 46 - . */
        TK_OP_ID,                       /* 47 - / */
        TK_OP_ID,                       /* 48 - 0 */
        TK_OP_ID,                       /* 49 - 1 */
        TK_OP_ID,                       /* 50 - 2 */
        TK_OP_ID,                       /* 51 - 3 */
        TK_OP_ID,                       /* 52 - 4 */
        TK_OP_ID,                       /* 53 - 5 */
        TK_OP_ID,                       /* 54 - 6 */
        TK_OP_ID,                       /* 55 - 7 */
        TK_OP_ID,                       /* 56 - 8 */
        TK_OP_ID,                       /* 57 - 9 */
        TK_COLON,                       /* 58 - : */
        TK_SEMICOLON,                   /* 59 - ; */
        TK_OP_ID,                       /* 60 - < */
        TK_EQUAL,                       /* 61 - = */
        TK_OP_ID,                       /* 62 - > */
        TK_OP_ID,                       /* 63 - ? */
        TK_ATSIGN,                      /* 64 - @ */
        TK_OP_ID,                       /* 65 - A */
        TK_OP_ID,                       /* 66 - B */
        TK_OP_ID,                       /* 67 - C */
        TK_OP_ID,                       /* 68 - D */
        TK_OP_ID,                       /* 69 - E */
        TK_OP_ID,                       /* 70 - F */
        TK_OP_ID,                       /* 71 - G */
        TK_OP_ID,                       /* 72 - H */
        TK_OP_ID,                       /* 73 - I */
        TK_OP_ID,                       /* 74 - J */
        TK_OP_ID,                       /* 75 - K */
        TK_OP_ID,                       /* 76 - L */
        TK_OP_ID,                       /* 77 - M */
        TK_OP_ID,                       /* 78 - N */
        TK_OP_ID,                       /* 79 - O */
        TK_OP_ID,                       /* 80 - P */
        TK_OP_ID,                       /* 81 - Q */
        TK_OP_ID,                       /* 82 - R */
        TK_OP_ID,                       /* 83 - S */
        TK_OP_ID,                       /* 84 - T */
        TK_OP_ID,                       /* 85 - U */
        TK_OP_ID,                       /* 86 - V */
        TK_OP_ID,                       /* 87 - W */
        TK_OP_ID,                       /* 88 - X */
        TK_OP_ID,                       /* 89 - Y */
        TK_OP_ID,                       /* 90 - Z */
        TK_OP_ID,                       /* 91 - [ */
        TK_OP_ID,                       /* 92 - \ */
        TK_OP_ID,                       /* 93 - ] */
        TK_OP_ID,                       /* 94 - ^ */
        TK_OP_ID,                       /* 95 - _ */
        TK_OP_ID,                       /* 96 - ` */
        TK_OP_ID,                       /* 97 - a */
        TK_OP_ID,                       /* 98 - b */
        TK_OP_ID,                       /* 99 - c */
        TK_OP_ID,                       /* 100 - d */
        TK_OP_ID,                       /* 101 - e */
        TK_OP_ID,                       /* 102 - f */
        TK_OP_ID,                       /* 103 - g */
        TK_OP_ID,                       /* 104 - h */
        TK_OP_ID,                       /* 105 - i */
        TK_OP_ID,                       /* 106 - j */
        TK_OP_ID,                       /* 107 - k */
        TK_OP_ID,                       /* 108 - l */
        TK_OP_ID,                       /* 109 - m */
        TK_OP_ID,                       /* 110 - n */
        TK_OP_ID,                       /* 111 - o */
        TK_OP_ID,                       /* 112 - p */
        TK_OP_ID,                       /* 113 - q */
        TK_OP_ID,                       /* 114 - r */
        TK_OP_ID,                       /* 115 - s */
        TK_OP_ID,                       /* 116 - t */
        TK_OP_ID,                       /* 117 - u */
        TK_OP_ID,                       /* 118 - v */
        TK_OP_ID,                       /* 119 - w */
        TK_OP_ID,                       /* 120 - x */
        TK_OP_ID,                       /* 121 - y */
        TK_OP_ID,                       /* 122 - z */
        TK_LEFTBKT,                     /* 123 - { */
        TK_PIPE,                        /* 124 - | */
        TK_RIGHTBKT,                    /* 125 - } */
        TK_OP_ID,                       /* 126 - ~ */
        TK_OP_ILLCHR,                   /* 127 - DEL */
};

/*
 * Version 2 syntax dispatch table for ld_map_gettoken(). For each of the
 * 7-bit ASCII characters, determine how the lexical analyzer should behave.
 *
 * This table must be kept in sync with tkid_attr[] below.
 *
 * Identifier Note:
 * We define a letter as being one of the character [A-Z], [a-z], or [_%/.]
 * A digit is the numbers [0-9], or [$-]. An unquoted identifier is defined
 * as a letter, followed by any number of letters or digits. This is a loosened
 * version of the C definition of an identifier. The extra characters not
 * allowed by C are common in section names and/or file paths.
 */
static const mf_tokdisp_t gettok_dispatch_v2 = {
        TK_OP_EOF,                      /* 0 - NUL */
        TK_OP_ILLCHR,                   /* 1 - SOH */
        TK_OP_ILLCHR,                   /* 2 - STX */
        TK_OP_ILLCHR,                   /* 3 - ETX */
        TK_OP_ILLCHR,                   /* 4 - EOT */
        TK_OP_ILLCHR,                   /* 5 - ENQ */
        TK_OP_ILLCHR,                   /* 6 - ACK */
        TK_OP_ILLCHR,                   /* 7 - BEL */
        TK_OP_ILLCHR,                   /* 8 - BS */
        TK_OP_WS,                       /* 9 - HT */
        TK_OP_NL,                       /* 10 - NL */
        TK_OP_WS,                       /* 11 - VT */
        TK_OP_WS,                       /* 12 - FF */
        TK_OP_WS,                       /* 13 - CR */
        TK_OP_ILLCHR,                   /* 14 - SO */
        TK_OP_ILLCHR,                   /* 15 - SI */
        TK_OP_ILLCHR,                   /* 16 - DLE */
        TK_OP_ILLCHR,                   /* 17 - DC1 */
        TK_OP_ILLCHR,                   /* 18 - DC2 */
        TK_OP_ILLCHR,                   /* 19 - DC3 */
        TK_OP_ILLCHR,                   /* 20 - DC4 */
        TK_OP_ILLCHR,                   /* 21 - NAK */
        TK_OP_ILLCHR,                   /* 22 - SYN */
        TK_OP_ILLCHR,                   /* 23 - ETB */
        TK_OP_ILLCHR,                   /* 24 - CAN */
        TK_OP_ILLCHR,                   /* 25 - EM */
        TK_OP_ILLCHR,                   /* 26 - SUB */
        TK_OP_ILLCHR,                   /* 27 - ESC */
        TK_OP_ILLCHR,                   /* 28 - FS */
        TK_OP_ILLCHR,                   /* 29 - GS */
        TK_OP_ILLCHR,                   /* 30 - RS */
        TK_OP_ILLCHR,                   /* 31 - US */
        TK_OP_WS,                       /* 32 - SP */
        TK_BANG,                        /* 33 - ! */
        TK_OP_CQUOTE,                   /* 34 - " */
        TK_OP_CMT,                      /* 35 - # */
        TK_OP_CDIR,                     /* 36 - $ */
        TK_OP_ID,                       /* 37 - % */
        TK_OP_BADCHR,                   /* 38 - & */
        TK_OP_SIMQUOTE,                 /* 39 - ' */
        TK_OP_BADCHR,                   /* 40 - ( */
        TK_OP_BADCHR,                   /* 41 - ) */
        TK_STAR,                        /* 42 - * */
        TK_OP_CEQUAL,                   /* 43 - + */
        TK_OP_BADCHR,                   /* 44 - , */
        TK_OP_CEQUAL,                   /* 45 - - */
        TK_OP_ID,                       /* 46 - . */
        TK_OP_ID,                       /* 47 - / */
        TK_OP_NUM,                      /* 48 - 0 */
        TK_OP_NUM,                      /* 49 - 1 */
        TK_OP_NUM,                      /* 50 - 2 */
        TK_OP_NUM,                      /* 51 - 3 */
        TK_OP_NUM,                      /* 52 - 4 */
        TK_OP_NUM,                      /* 53 - 5 */
        TK_OP_NUM,                      /* 54 - 6 */
        TK_OP_NUM,                      /* 55 - 7 */
        TK_OP_NUM,                      /* 56 - 8 */
        TK_OP_NUM,                      /* 57 - 9 */
        TK_COLON,                       /* 58 - : */
        TK_SEMICOLON,                   /* 59 - ; */
        TK_OP_BADCHR,                   /* 60 - < */
        TK_EQUAL,                       /* 61 - = */
        TK_OP_BADCHR,                   /* 62 - > */
        TK_OP_BADCHR,                   /* 63 - ? */
        TK_OP_BADCHR,                   /* 64 - @ */
        TK_OP_ID,                       /* 65 - A */
        TK_OP_ID,                       /* 66 - B */
        TK_OP_ID,                       /* 67 - C */
        TK_OP_ID,                       /* 68 - D */
        TK_OP_ID,                       /* 69 - E */
        TK_OP_ID,                       /* 70 - F */
        TK_OP_ID,                       /* 71 - G */
        TK_OP_ID,                       /* 72 - H */
        TK_OP_ID,                       /* 73 - I */
        TK_OP_ID,                       /* 74 - J */
        TK_OP_ID,                       /* 75 - K */
        TK_OP_ID,                       /* 76 - L */
        TK_OP_ID,                       /* 77 - M */
        TK_OP_ID,                       /* 78 - N */
        TK_OP_ID,                       /* 79 - O */
        TK_OP_ID,                       /* 80 - P */
        TK_OP_ID,                       /* 81 - Q */
        TK_OP_ID,                       /* 82 - R */
        TK_OP_ID,                       /* 83 - S */
        TK_OP_ID,                       /* 84 - T */
        TK_OP_ID,                       /* 85 - U */
        TK_OP_ID,                       /* 86 - V */
        TK_OP_ID,                       /* 87 - W */
        TK_OP_ID,                       /* 88 - X */
        TK_OP_ID,                       /* 89 - Y */
        TK_OP_ID,                       /* 90 - Z */
        TK_OP_BADCHR,                   /* 91 - [ */
        TK_OP_BADCHR,                   /* 92 - \ */
        TK_OP_BADCHR,                   /* 93 - ] */
        TK_OP_BADCHR,                   /* 94 - ^ */
        TK_OP_ID,                       /* 95 - _ */
        TK_OP_BADCHR,                   /* 96 - ` */
        TK_OP_ID,                       /* 97 - a */
        TK_OP_ID,                       /* 98 - b */
        TK_OP_ID,                       /* 99 - c */
        TK_OP_ID,                       /* 100 - d */
        TK_OP_ID,                       /* 101 - e */
        TK_OP_ID,                       /* 102 - f */
        TK_OP_ID,                       /* 103 - g */
        TK_OP_ID,                       /* 104 - h */
        TK_OP_ID,                       /* 105 - i */
        TK_OP_ID,                       /* 106 - j */
        TK_OP_ID,                       /* 107 - k */
        TK_OP_ID,                       /* 108 - l */
        TK_OP_ID,                       /* 109 - m */
        TK_OP_ID,                       /* 110 - n */
        TK_OP_ID,                       /* 111 - o */
        TK_OP_ID,                       /* 112 - p */
        TK_OP_ID,                       /* 113 - q */
        TK_OP_ID,                       /* 114 - r */
        TK_OP_ID,                       /* 115 - s */
        TK_OP_ID,                       /* 116 - t */
        TK_OP_ID,                       /* 117 - u */
        TK_OP_ID,                       /* 118 - v */
        TK_OP_ID,                       /* 119 - w */
        TK_OP_ID,                       /* 120 - x */
        TK_OP_ID,                       /* 121 - y */
        TK_OP_ID,                       /* 122 - z */
        TK_LEFTBKT,                     /* 123 - { */
        TK_OP_BADCHR,                   /* 124 - | */
        TK_RIGHTBKT,                    /* 125 - } */
        TK_OP_BADCHR,                   /* 126 - ~ */
        TK_OP_ILLCHR,                   /* 127 - DEL */
};


/*
 * Table used to identify unquoted identifiers. Each element of this array
 * contains a bitmask indicating whether the character it represents starts,
 * or continues an identifier, for each supported mapfile syntax version.
 */
static const char tkid_attr[128] = {
        0,                                      /* 0 - NUL */
        TKID_ATTR_CONT(1),                      /* 1 - SOH */
        TKID_ATTR_CONT(1),                      /* 2 - STX */
        TKID_ATTR_CONT(1),                      /* 3 - ETX */
        TKID_ATTR_CONT(1),                      /* 4 - EOT */
        TKID_ATTR_CONT(1),                      /* 5 - ENQ */
        TKID_ATTR_CONT(1),                      /* 6 - ACK */
        TKID_ATTR_CONT(1),                      /* 7 - BEL */
        TKID_ATTR_CONT(1),                      /* 8 - BS */
        0,                                      /* 9 - HT */
        0,                                      /* 10 - NL */
        TKID_ATTR_CONT(1),                      /* 11 - VT */
        TKID_ATTR_CONT(1),                      /* 12 - FF */
        TKID_ATTR_CONT(1),                      /* 13 - CR */
        TKID_ATTR_CONT(1),                      /* 14 - SO */
        TKID_ATTR_CONT(1),                      /* 15 - SI */
        TKID_ATTR_CONT(1),                      /* 16 - DLE */
        TKID_ATTR_CONT(1),                      /* 17 - DC1 */
        TKID_ATTR_CONT(1),                      /* 18 - DC2 */
        TKID_ATTR_CONT(1),                      /* 19 - DC3 */
        TKID_ATTR_CONT(1),                      /* 20 - DC4 */
        TKID_ATTR_CONT(1),                      /* 21 - NAK */
        TKID_ATTR_CONT(1),                      /* 22 - SYN */
        TKID_ATTR_CONT(1),                      /* 23 - ETB */
        TKID_ATTR_CONT(1),                      /* 24 - CAN */
        TKID_ATTR_CONT(1),                      /* 25 - EM */
        TKID_ATTR_CONT(1),                      /* 26 - SUB */
        TKID_ATTR_CONT(1),                      /* 27 - ESC */
        TKID_ATTR_CONT(1),                      /* 28 - FS */
        TKID_ATTR_CONT(1),                      /* 29 - GS */
        TKID_ATTR_CONT(1),                      /* 30 - RS */
        TKID_ATTR_CONT(1),                      /* 31 - US */
        0,                                      /* 32 - SP */
        TKID_ATTR(1),                           /* 33 - ! */
        0,                                      /* 34 - " */
        0,                                      /* 35 - # */
        TKID_ATTR(1) | TKID_ATTR_CONT(2),       /* 36 - $ */
        TKID_ATTR(1) | TKID_ATTR_CONT(2),       /* 37 - % */
        TKID_ATTR(1),                           /* 38 - & */
        TKID_ATTR(1),                           /* 39 - ' */
        TKID_ATTR(1),                           /* 40 - ( */
        TKID_ATTR(1),                           /* 41 - ) */
        TKID_ATTR(1),                           /* 42 - * */
        TKID_ATTR(1),                           /* 43 - + */
        TKID_ATTR(1),                           /* 44 - , */
        TKID_ATTR_CONT(1) | TKID_ATTR_CONT(2),  /* 45 - - */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 46 - . */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 47 - / */
        TKID_ATTR(1) | TKID_ATTR_CONT(2),       /* 48 - 0 */
        TKID_ATTR(1) | TKID_ATTR_CONT(2),       /* 49 - 1 */
        TKID_ATTR(1) | TKID_ATTR_CONT(2),       /* 50 - 2 */
        TKID_ATTR(1) | TKID_ATTR_CONT(2),       /* 51 - 3 */
        TKID_ATTR(1) | TKID_ATTR_CONT(2),       /* 52 - 4 */
        TKID_ATTR(1) | TKID_ATTR_CONT(2),       /* 53 - 5 */
        TKID_ATTR(1) | TKID_ATTR_CONT(2),       /* 54 - 6 */
        TKID_ATTR(1) | TKID_ATTR_CONT(2),       /* 55 - 7 */
        TKID_ATTR(1) | TKID_ATTR_CONT(2),       /* 56 - 8 */
        TKID_ATTR(1) | TKID_ATTR_CONT(2),       /* 57 - 9 */
        0,                                      /* 58 - : */
        0,                                      /* 59 - ; */
        TKID_ATTR(1),                           /* 60 - < */
        0,                                      /* 61 - = */
        TKID_ATTR(1),                           /* 62 - > */
        TKID_ATTR(1),                           /* 63 - ? */
        TKID_ATTR_CONT(1),                      /* 64 - @ */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 65 - A */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 66 - B */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 67 - C */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 68 - D */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 69 - E */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 70 - F */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 71 - G */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 72 - H */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 73 - I */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 74 - J */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 75 - K */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 76 - L */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 77 - M */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 78 - N */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 79 - O */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 80 - P */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 81 - Q */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 82 - R */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 83 - S */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 84 - T */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 85 - U */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 86 - V */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 87 - W */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 88 - X */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 89 - Y */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 90 - Z */
        TKID_ATTR(1),                           /* 91 - [ */
        TKID_ATTR(1),                           /* 92 - \ */
        TKID_ATTR(1),                           /* 93 - ] */
        TKID_ATTR(1),                           /* 94 - ^ */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 95 - _ */
        TKID_ATTR(1),                           /* 96 - ` */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 97 - a */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 98 - b */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 99 - c */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 100 - d */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 101 - e */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 102 - f */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 103 - g */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 104 - h */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 105 - i */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 106 - j */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 107 - k */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 108 - l */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 109 - m */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 110 - n */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 111 - o */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 112 - p */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 113 - q */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 114 - r */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 115 - s */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 116 - t */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 117 - u */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 118 - v */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 119 - w */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 120 - x */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 121 - y */
        TKID_ATTR(1) | TKID_ATTR(2),            /* 122 - z */
        TKID_ATTR_CONT(1),                      /* 123 - { */
        TKID_ATTR_CONT(1),                      /* 124 - | */
        TKID_ATTR_CONT(1),                      /* 125 - } */
        TKID_ATTR(1),                           /* 126 - ~ */
        TKID_ATTR_CONT(1),                      /* 127 - DEL */
};


/*
 * Advance the given string pointer to the next newline character,
 * or the terminating NULL if there is none.
 */
inline static void
advance_to_eol(char **str)
{
        char    *s = *str;

        while ((*s != '\n') && (*s != '\0'))
                s++;
        *str = s;
}

/*
 * Insert a NULL patch at the given address
 */
inline static void
null_patch_set(char *str, ld_map_npatch_t *np)
{
        np->np_ptr = str;
        np->np_ch = *str;
        *str = '\0';
}

/*
 * Undo a NULL patch
 */
inline static void
null_patch_undo(ld_map_npatch_t *np)
{
        *np->np_ptr = np->np_ch;
}

/*
 * Insert a NULL patch at the end of the line containing str.
 */
static void
null_patch_eol(char *str, ld_map_npatch_t *np)
{
        advance_to_eol(&str);
        null_patch_set(str, np);
}

/*
 * Locate the end of an unquoted identifier.
 *
 * entry:
 *      mf - Mapfile descriptor, positioned to first character
 *              of identifier.
 *
 * exit:
 *      If the item pointed at by mf is not an identifier, returns NULL.
 *      Otherwise, returns pointer to character after the last character
 *      of the identifier.
 */
inline static char *
ident_delimit(Mapfile *mf)
{
        char            *str = mf->mf_next;
        ld_map_npatch_t np;
        int             c = *str++;

        /* If not a valid start character, report the error */
        if ((c & 0x80) || !(tkid_attr[c] & mf->mf_tkid_start)) {
                null_patch_set(str, &np);
                mf_fatal(mf, MSG_INTL(MSG_MAP_BADCHAR), str);
                null_patch_undo(&np);
                return (NULL);
        }

        /* Keep going until we hit a non-continuing character */
        for (c = *str; !(c & 0x80) && (tkid_attr[c] & mf->mf_tkid_cont);
            c = *++str)
                ;

        return (str);
}

/*
 * Allocate memory for a stack.
 *
 * entry:
 *      stack - Pointer to stack for which memory is required, cast
 *              to the generic stack type.
 *      n_default - Size to use for initial allocation.
 *      elt_size - sizeof(elt), where elt is the actual stack data type.
 *
 * exit:
 *      Returns (1) on success. On error (memory allocation), a message
 *      is printed and False (0) is returned.
 *
 * note:
 *      The caller casts the pointer to their actual datatype-specific stack
 *      to be a (generic_stack_t *). The C language will give all stack
 *      structs the same size and layout as long as the underlying platform
 *      uses a single integral type for pointers. Hence, this cast is safe,
 *      and lets a generic routine modify data-specific types without being
 *      aware of those types.
 */
static Boolean
stack_resize(generic_stack_t *stack, size_t n_default, size_t elt_size)
{
        size_t  new_n_alloc;
        void    *newaddr;

        /* Use initial size first, and double the allocation on each call */
        new_n_alloc = (stack->stk_n_alloc == 0) ?
            n_default : (stack->stk_n_alloc * 2);

        newaddr = libld_realloc(stack->stk_s, new_n_alloc * elt_size);
        if (newaddr == NULL)
                return (FALSE);

        stack->stk_s = newaddr;
        stack->stk_n_alloc = new_n_alloc;
        return (TRUE);
}

/*
 * AVL comparison function for cexp_id_node_t items.
 *
 * entry:
 *      n1, n2 - pointers to nodes to be compared
 *
 * exit:
 *      Returns -1 if (n1 < n2), 0 if they are equal, and 1 if (n1 > n2)
 */
static int
cexp_ident_cmp(const void *n1, const void *n2)
{
        int     rc;

        rc = strcmp(((cexp_id_node_t *)n1)->ceid_name,
            ((cexp_id_node_t *)n2)->ceid_name);

        if (rc > 0)
                return (1);
        if (rc < 0)
                return (-1);
        return (0);
}


/*
 * Returns True (1) if name is in the conditional expression identifier
 * AVL tree, and False (0) otherwise.
 */
static int
cexp_ident_test(const char *name)
{
        cexp_id_node_t  node;

        node.ceid_name = name;
        return (avl_find(lms.lms_cexp_id, &node, 0) != NULL);
}

/*
 * Add a new boolean identifier to the conditional expression identifier
 * AVL tree.
 *
 * entry:
 *      mf - If non-NULL, the mapfile descriptor for the mapfile
 *              containing the $add directive. NULL if this is an
 *              initialization call.
 *      name - Name of identifier. Must point at stable storage that will
 *              not be moved or modified by the caller following this call.
 *
 * exit:
 *      On success, True (1) is returned and name has been entered.
 *      On failure, False (0) is returned and an error has been printed.
 */
static int
cexp_ident_add(Mapfile *mf, const char *name)
{
        cexp_id_node_t  *node;

        if (mf != NULL) {
                DBG_CALL(Dbg_map_cexp_id(mf->mf_ofl->ofl_lml, 1,
                    mf->mf_name, mf->mf_lineno, name));

                /* If is already known, don't do it again */
                if (cexp_ident_test(name))
                        return (1);
        }

        if ((node = libld_calloc(sizeof (*node), 1)) == NULL)
                return (0);
        node->ceid_name = name;
        avl_add(lms.lms_cexp_id, node);
        return (1);
}

/*
 * Remove a boolean identifier from the conditional expression identifier
 * AVL tree.
 *
 * entry:
 *      mf - Mapfile descriptor
 *      name - Name of identifier.
 *
 * exit:
 *      If the name was in the tree, it has been removed. If not,
 *      then this routine quietly returns.
 */
static void
cexp_ident_clear(Mapfile *mf, const char *name)
{
        cexp_id_node_t  node;
        cexp_id_node_t  *real_node;

        DBG_CALL(Dbg_map_cexp_id(mf->mf_ofl->ofl_lml, 0,
            mf->mf_name, mf->mf_lineno, name));

        node.ceid_name = name;
        real_node = avl_find(lms.lms_cexp_id, &node, 0);
        if (real_node != NULL)
                avl_remove(lms.lms_cexp_id, real_node);
}

/*
 * Initialize the AVL tree that holds the names of the currently defined
 * boolean identifiers for conditional expressions ($if/$elif).
 *
 * entry:
 *      ofl - Output file descriptor
 *
 * exit:
 *      On success, TRUE (1) is returned and lms.lms_cexp_id is ready for use.
 *      On failure, FALSE (0) is returned.
 */
static Boolean
cexp_ident_init(void)
{
        /* If already done, use it */
        if (lms.lms_cexp_id != NULL)
                return (TRUE);

        lms.lms_cexp_id = libld_calloc(sizeof (*lms.lms_cexp_id), 1);
        if (lms.lms_cexp_id == NULL)
                return (FALSE);
        avl_create(lms.lms_cexp_id, cexp_ident_cmp, sizeof (cexp_id_node_t),
            SGSOFFSETOF(cexp_id_node_t, ceid_avlnode));


        /* ELFCLASS */
        if (cexp_ident_add(NULL, (ld_targ.t_m.m_class == ELFCLASS32) ?
            MSG_ORIG(MSG_STR_UELF32) : MSG_ORIG(MSG_STR_UELF64)) == 0)
                return (FALSE);

        /* Machine */
        switch (ld_targ.t_m.m_mach) {
        case EM_386:
        case EM_AMD64:
                if (cexp_ident_add(NULL, MSG_ORIG(MSG_STR_UX86)) == 0)
                        return (FALSE);
                break;

        case EM_SPARC:
        case EM_SPARCV9:
                if (cexp_ident_add(NULL, MSG_ORIG(MSG_STR_USPARC)) == 0)
                        return (FALSE);
                break;
        }

        /* true is always defined */
        if (cexp_ident_add(NULL, MSG_ORIG(MSG_STR_TRUE)) == 0)
                return (FALSE);

        return (TRUE);
}

/*
 * Validate the string starting at mf->mf_next as being a
 * boolean conditional expression identifier.
 *
 * entry:
 *      mf - Mapfile descriptor
 *      len - NULL, or address of variable to receive strlen() of identifier
 *      directive - If (len == NULL), string giving name of directive being
 *              processed. Ignored if (len != NULL).
 *
 * exit:
 *      On success:
 *      -       If len is NULL, a NULL is inserted following the final
 *              character of the identifier, and the remainder of the string
 *              is tested to ensure it is empty, or only contains whitespace.
 *      -       If len is non-NULL, *len is set to the number of characters
 *              in the identifier, and the rest of the string is not modified.
 *      -       TRUE (1) is returned
 *
 *      On failure, returns FALSE (0).
 */
static Boolean
cexp_ident_validate(Mapfile *mf, size_t *len, const char *directive)
{
        char    *tail;

        if ((tail = ident_delimit(mf)) == NULL)
                return (FALSE);

        /*
         * If len is non-NULL, we simple count the number of characters
         * consumed by the identifier and are done. If len is NULL, then
         * ensure there's nothing left but whitespace, and NULL terminate
         * the identifier to remove it.
         */
        if (len != NULL) {
                *len = tail - mf->mf_next;
        } else if (*tail != '\0') {
                *tail++ = '\0';
                while (isspace(*tail))
                        tail++;
                if (*tail != '\0') {
                        mf_fatal(mf, MSG_INTL(MSG_MAP_BADEXTRA), directive);
                        return (FALSE);
                }
        }

        return (TRUE);
}

/*
 * Push a new operator onto the conditional expression operator stack.
 *
 * entry:
 *      mf - Mapfile descriptor
 *      op - Operator to push
 *
 * exit:
 *      On success, TRUE (1) is returned, otherwise FALSE (0).
 */
static Boolean
cexp_push_op(cexp_op_t op)
{
        if (STACK_RESERVE(lms.lms_cexp_op_stack, CEXP_OP_STACK_INIT) == 0)
                return (FALSE);

        STACK_PUSH(lms.lms_cexp_op_stack) = op;
        return (TRUE);
}

/*
 * Evaluate the basic operator (non-paren) at the top of lms.lms_cexp_op_stack,
 * and push the results on lms.lms_cexp_val_stack.
 *
 * exit:
 *      On success, returns TRUE (1). On error, FALSE (0) is returned,
 *      and the caller is responsible for issuing the error.
 */
static Boolean
cexp_eval_op(void)
{
        cexp_op_t       op;
        uchar_t         val;

        op = STACK_POP(lms.lms_cexp_op_stack);
        switch (op) {
        case CEXP_OP_AND:
                if (lms.lms_cexp_val_stack.stk_n < 2)
                        return (FALSE);
                val = STACK_POP(lms.lms_cexp_val_stack);
                STACK_TOP(lms.lms_cexp_val_stack) = val &&
                    STACK_TOP(lms.lms_cexp_val_stack);
                break;

        case CEXP_OP_OR:
                if (lms.lms_cexp_val_stack.stk_n < 2)
                        return (FALSE);
                val = STACK_POP(lms.lms_cexp_val_stack);
                STACK_TOP(lms.lms_cexp_val_stack) = val ||
                    STACK_TOP(lms.lms_cexp_val_stack);
                break;

        case CEXP_OP_NEG:
                if (lms.lms_cexp_val_stack.stk_n < 1)
                        return (FALSE);
                STACK_TOP(lms.lms_cexp_val_stack) =
                    !STACK_TOP(lms.lms_cexp_val_stack);
                break;
        default:
                return (FALSE);
        }

        return (TRUE);
}

/*
 * Evaluate an expression for a $if/$elif control directive.
 *
 * entry:
 *      mf - Mapfile descriptor for NULL terminated string
 *              containing the expression.
 *
 * exit:
 *      The contents of str are modified by this routine.
 *      One of the following values are returned:
 *              -1      Syntax error encountered (an error is printed)
 *              0       The expression evaluates to False
 *              1       The expression evaluates to True.
 *
 * note:
 *      A simplified version of Dijkstra's Shunting Yard algorithm is used
 *      to convert this syntax into postfix form and then evaluate it.
 *      Our version has no functions and a tiny set of operators.
 *
 *      The expressions consist of boolean identifiers, which can be
 *      combined using the following operators, listed from highest
 *      precedence to least:
 *
 *              Operator        Meaning
 *              -------------------------------------------------
 *              (expr)          sub-expression, non-associative
 *              !               logical negation, prefix, left associative
 *              &&  ||          logical and/or, binary, left associative
 *
 *      The operands manipulated by these operators are names, consisting of
 *      a sequence of letters and digits. The first character must be a letter.
 *      Underscore (_) and period (.) are also considered to be characters.
 *      An operand is considered True if it is found in our set of known
 *      names (lms.lms_cexp_id), and False otherwise.
 *
 *      The Shunting Yard algorithm works using two stacks, one for operators,
 *      and a second for operands. The infix input expression is tokenized from
 *      left to right and processed in order. Issues of associativity and
 *      precedence are managed by reducing (poping and evaluating) items with
 *      higer precedence before pushing additional tokens with lower precedence.
 */
static int
cexp_eval_expr(Mapfile *mf)
{
        char            *ident;
        size_t          len;
        cexp_op_t       new_op = CEXP_OP_AND;   /* to catch binop at start */
        ld_map_npatch_t np;
        char            *str = mf->mf_next;

        STACK_RESET(lms.lms_cexp_op_stack);
        STACK_RESET(lms.lms_cexp_val_stack);

        for (; *str; str++) {

                /* Skip whitespace */
                while (isspace(*str))
                        str++;
                if (!*str)
                        break;

                switch (*str) {
                case '&':
                case '|':
                        if (*(str + 1) != *str)
                                goto token_error;
                        if ((new_op != CEXP_OP_NONE) &&
                            (new_op != CEXP_OP_CPAR)) {
                                mf_fatal0(mf, MSG_INTL(MSG_MAP_CEXP_BADOPUSE));
                                return (-1);
                        }
                        str++;

                        /*
                         * As this is a left associative binary operator, we
                         * need to process all operators of equal or higher
                         * precedence before pushing the new operator.
                         */
                        while (!STACK_IS_EMPTY(lms.lms_cexp_op_stack)) {
                                cexp_op_t op = STACK_TOP(lms.lms_cexp_op_stack);


                                if ((op != CEXP_OP_AND) && (op != CEXP_OP_OR) &&
                                    (op != CEXP_OP_NEG))
                                        break;

                                if (!cexp_eval_op())
                                        goto semantic_error;
                        }

                        new_op = (*str == '&') ? CEXP_OP_AND : CEXP_OP_OR;
                        if (!cexp_push_op(new_op))
                                return (-1);
                        break;

                case '!':
                        new_op = CEXP_OP_NEG;
                        if (!cexp_push_op(new_op))
                                return (-1);
                        break;

                case '(':
                        new_op = CEXP_OP_OPAR;
                        if (!cexp_push_op(new_op))
                                return (-1);
                        break;

                case ')':
                        new_op = CEXP_OP_CPAR;

                        /* Evaluate the operator stack until reach '(' */
                        while (!STACK_IS_EMPTY(lms.lms_cexp_op_stack) &&
                            (STACK_TOP(lms.lms_cexp_op_stack) != CEXP_OP_OPAR))
                                if (!cexp_eval_op())
                                        goto semantic_error;

                        /*
                         * If the top of operator stack is not an open paren,
                         * when we have an error. In this case, the operator
                         * stack will be empty due to the loop above.
                         */
                        if (STACK_IS_EMPTY(lms.lms_cexp_op_stack))
                                goto unbalpar_error;
                        lms.lms_cexp_op_stack.stk_n--;   /* Pop OPAR */
                        break;

                default:
                        /* Ensure there's room to push another operand */
                        if (STACK_RESERVE(lms.lms_cexp_val_stack,
                            CEXP_VAL_STACK_INIT) == 0)
                                return (0);
                        new_op = CEXP_OP_NONE;

                        /*
                         * Operands cannot be numbers. However, we accept two
                         * special cases: '0' means false, and '1' is true.
                         * This is done to support the common C idiom of
                         * '#if 1' and '#if 0' to conditionalize code under
                         * development.
                         */
                        if ((*str == '0') || (*str == '1')) {
                                STACK_PUSH(lms.lms_cexp_val_stack) =
                                    (*str == '1');
                                break;
                        }

                        /* Look up the identifier */
                        ident = mf->mf_next = str;
                        if (!cexp_ident_validate(mf, &len, NULL))
                                return (-1);
                        str += len - 1;   /* loop will advance past final ch */
                        null_patch_set(&ident[len], &np);
                        STACK_PUSH(lms.lms_cexp_val_stack) =
                            cexp_ident_test(ident);
                        null_patch_undo(&np);

                        break;
                }
        }

        /* Evaluate the operator stack until empty */
        while (!STACK_IS_EMPTY(lms.lms_cexp_op_stack)) {
                if (STACK_TOP(lms.lms_cexp_op_stack) == CEXP_OP_OPAR)
                        goto unbalpar_error;

                if (!cexp_eval_op())
                        goto semantic_error;
        }

        /* There should be exactly one value left */
        if (lms.lms_cexp_val_stack.stk_n != 1)
                goto semantic_error;

        /* Final value is the result */
        return (lms.lms_cexp_val_stack.stk_s[0]);

        /* Errors issued more than once are handled below, accessed via goto */

token_error:                    /* unexpected characters in input stream */
        mf_fatal(mf, MSG_INTL(MSG_MAP_CEXP_TOKERR), str);
        return (-1);

semantic_error:                 /* valid tokens, but in invalid arrangement */
        mf_fatal0(mf, MSG_INTL(MSG_MAP_CEXP_SEMERR));
        return (-1);

unbalpar_error:                 /* Extra or missing parenthesis */
        mf_fatal0(mf, MSG_INTL(MSG_MAP_CEXP_UNBALPAR));
        return (-1);
}

/*
 * Process a mapfile control directive. These directives start with
 * the dollar character, and are used to manage details of the mapfile
 * itself, such as version and conditional input.
 *
 * entry:
 *      mf - Mapfile descriptor
 *
 * exit:
 *      Returns TRUE (1) for success, and FALSE (0) on error. In the
 *      error case, a descriptive error is issued.
 */
static Boolean
cdir_process(Mapfile *mf)
{
        typedef enum {                  /* Directive types */
                CDIR_T_UNKNOWN = 0,     /* Unrecognized control directive */
                CDIR_T_ADD,             /* $add */
                CDIR_T_CLEAR,           /* $clear */
                CDIR_T_ERROR,           /* $error */
                CDIR_T_VERSION,         /* $mapfile_version */
                CDIR_T_IF,              /* $if */
                CDIR_T_ELIF,            /* $elif */
                CDIR_T_ELSE,            /* $else */
                CDIR_T_ENDIF,           /* $endif */
        } cdir_t;

        typedef enum {          /* Types of arguments accepted by directives */
                ARG_T_NONE,     /* Directive takes no arguments */
                ARG_T_EXPR,     /* Directive takes a conditional expression */
                ARG_T_ID,       /* Conditional expression identifier */
                ARG_T_STR,      /* Non-empty string */
                ARG_T_IGN       /* Ignore the argument */
        } cdir_arg_t;

        typedef struct {
                const char      *md_name;       /* Directive name */
                size_t          md_size;        /* strlen(md_name) */
                cdir_arg_t      md_arg;         /* Type of arguments */
                cdir_t          md_op;          /* CDIR_T_ code */
        } cdir_match_t;

        /* Control Directives: The most likely items are listed first */
        static cdir_match_t match_data[] = {
                { MSG_ORIG(MSG_STR_CDIR_IF),    MSG_STR_CDIR_IF_SIZE,
                    ARG_T_EXPR,                 CDIR_T_IF },
                { MSG_ORIG(MSG_STR_CDIR_ENDIF), MSG_STR_CDIR_ENDIF_SIZE,
                    ARG_T_NONE,                 CDIR_T_ENDIF },
                { MSG_ORIG(MSG_STR_CDIR_ELSE),  MSG_STR_CDIR_ELSE_SIZE,
                    ARG_T_NONE,                 CDIR_T_ELSE },
                { MSG_ORIG(MSG_STR_CDIR_ELIF),  MSG_STR_CDIR_ELIF_SIZE,
                    ARG_T_EXPR,                 CDIR_T_ELIF },
                { MSG_ORIG(MSG_STR_CDIR_ERROR), MSG_STR_CDIR_ERROR_SIZE,
                    ARG_T_STR,                  CDIR_T_ERROR },
                { MSG_ORIG(MSG_STR_CDIR_ADD),   MSG_STR_CDIR_ADD_SIZE,
                    ARG_T_ID,                   CDIR_T_ADD },
                { MSG_ORIG(MSG_STR_CDIR_CLEAR), MSG_STR_CDIR_CLEAR_SIZE,
                    ARG_T_ID,                   CDIR_T_CLEAR },
                { MSG_ORIG(MSG_STR_CDIR_MFVER), MSG_STR_CDIR_MFVER_SIZE,
                    ARG_T_IGN,                  CDIR_T_VERSION },

                { NULL,                         0,
                    ARG_T_IGN,                  CDIR_T_UNKNOWN }
        };

        cdir_match_t    *mdptr;
        char            *tail;
        int             expr_eval;      /* Result of evaluating ARG_T_EXPR */
        Mapfile         arg_mf;
        cdir_level_t    *level;
        int             pass, parent_pass;      /* Currently accepting input */

restart:
        /* Is the immediate context passing input? */
        pass = STACK_IS_EMPTY(lms.lms_cdir_stack) ||
            STACK_TOP(lms.lms_cdir_stack).cdl_pass;

        /* Is the surrounding (parent) context passing input? */
        parent_pass = (lms.lms_cdir_stack.stk_n <= 1) ||
            lms.lms_cdir_stack.stk_s[lms.lms_cdir_stack.stk_n - 2].cdl_pass;


        for (mdptr = match_data; mdptr->md_name; mdptr++) {
                /* Prefix must match, or we move on */
                if (strncmp(mf->mf_next, mdptr->md_name,
                    mdptr->md_size) != 0)
                        continue;
                tail = mf->mf_next + mdptr->md_size;

                /*
                 * If there isn't whitespace, or a NULL terminator following
                 * the prefix, then even though our prefix matched, the actual
                 * token is longer, and we don't have a match.
                 */
                if (!isspace(*tail) && (*tail != '\0'))
                        continue;

                /* We have matched a valid control directive */
                break;
        }

        /* Advance input to end of the current line */
        advance_to_eol(&mf->mf_next);

        /*
         * Set up a temporary mapfile descriptor to reference the
         * argument string. The benefit of this second block, is that
         * we can advance the real one to the next line now, which allows
         * us to return at any time knowing that the input has been moved
         * to the proper spot. This simplifies the error cases.
         *
         * If we had a match, tail points at the start of the string.
         * Otherwise, we want to point at the end of the line.
         */
        arg_mf = *mf;
        if (mdptr->md_name == NULL)
                arg_mf.mf_text = arg_mf.mf_next;
        else
                arg_mf.mf_text = arg_mf.mf_next = tail;

        /*
         * Null terminate the arguments, and advance the main mapfile
         * state block to the next line.
         */
        if (*mf->mf_next == '\n') {
                *mf->mf_next++ = '\0';
                mf->mf_lineno++;
        }

        /* Skip leading whitespace to arguments */
        while (isspace(*arg_mf.mf_next))
                arg_mf.mf_next++;

        /* Strip off any comment present on the line */
        for (tail = arg_mf.mf_next; *tail; tail++)
                if (*tail == '#') {
                        *tail = '\0';
                        break;
                }

        /*
         * Process the arguments as necessary depending on their type.
         * If this control directive is nested inside a surrounding context
         * that is not currently passing text, then we skip the argument
         * evaluation. This follows the behavior of the C preprocessor,
         * which only examines enough to detect the operation within
         * a disabled section, without issuing errors about the arguments.
         */
        if (pass || (parent_pass && (mdptr->md_op == CDIR_T_ELIF))) {
                switch (mdptr->md_arg) {
                case ARG_T_NONE:
                        if (*arg_mf.mf_next == '\0')
                                break;
                        /* Args are present, but not wanted */
                        mf_fatal(&arg_mf, MSG_INTL(MSG_MAP_CDIR_REQNOARG),
                            mdptr->md_name);
                        return (FALSE);

                case ARG_T_EXPR:
                        /* Ensure that arguments are present */
                        if (*arg_mf.mf_next == '\0')
                                goto error_reqarg;
                        expr_eval = cexp_eval_expr(&arg_mf);
                        if (expr_eval == -1)
                                return (FALSE);
                        break;

                case ARG_T_ID:
                        /* Ensure that arguments are present */
                        if (*arg_mf.mf_next == '\0')
                                goto error_reqarg;
                        if (!cexp_ident_validate(&arg_mf, NULL,
                            mdptr->md_name))
                                return (FALSE);
                        break;

                case ARG_T_STR:
                        /* Ensure that arguments are present */
                        if (*arg_mf.mf_next == '\0')
                                goto error_reqarg;
                        /* Remove trailing whitespace */
                        tail = arg_mf.mf_next + strlen(arg_mf.mf_next);
                        while ((tail > arg_mf.mf_next) &&
                            isspace(*(tail -1)))
                                tail--;
                        *tail = '\0';
                        break;
                }
        }

        /*
         * Carry out the specified control directive:
         */
        if (!STACK_IS_EMPTY(lms.lms_cdir_stack))
                level = &STACK_TOP(lms.lms_cdir_stack);

        switch (mdptr->md_op) {
        case CDIR_T_UNKNOWN:            /* Unrecognized control directive */
                if (!pass)
                        break;
                mf_fatal0(&arg_mf, MSG_INTL(MSG_MAP_CDIR_BAD));
                return (FALSE);

        case CDIR_T_ADD:
                if (pass && !cexp_ident_add(&arg_mf, arg_mf.mf_next))
                        return (FALSE);
                break;

        case CDIR_T_CLEAR:
                if (pass)
                        cexp_ident_clear(&arg_mf, arg_mf.mf_next);
                break;

        case CDIR_T_ERROR:
                if (!pass)
                        break;
                mf_fatal(&arg_mf, MSG_INTL(MSG_MAP_CDIR_ERROR),
                    arg_mf.mf_next);
                return (FALSE);

        case CDIR_T_VERSION:
                /*
                 * A $mapfile_version control directive can only appear
                 * as the first directive in a mapfile, and is used to
                 * determine the syntax for the rest of the file. It's
                 * too late to be using it here.
                 */
                if (!pass)
                        break;
                mf_fatal0(&arg_mf, MSG_INTL(MSG_MAP_CDIR_REPVER));
                return (FALSE);

        case CDIR_T_IF:
                /* Push a new level on the conditional input stack */
                if (STACK_RESERVE(lms.lms_cdir_stack, CDIR_STACK_INIT) == 0)
                        return (FALSE);
                level = &lms.lms_cdir_stack.stk_s[lms.lms_cdir_stack.stk_n++];
                level->cdl_if_lineno = arg_mf.mf_lineno;
                level->cdl_else_lineno = 0;

                /*
                 * If previous level is not passing, this level is disabled.
                 * Otherwise, the expression value determines what happens.
                 */
                if (pass) {
                        level->cdl_done = level->cdl_pass = expr_eval;
                } else {
                        level->cdl_done = 1;
                        level->cdl_pass = 0;
                }
                break;

        case CDIR_T_ELIF:
                /* $elif requires an open $if construct */
                if (STACK_IS_EMPTY(lms.lms_cdir_stack)) {
                        mf_fatal(&arg_mf, MSG_INTL(MSG_MAP_CDIR_NOIF),
                            MSG_ORIG(MSG_STR_CDIR_ELIF));
                        return (FALSE);
                }

                /* $elif cannot follow $else */
                if (level->cdl_else_lineno > 0) {
                        mf_fatal(&arg_mf, MSG_INTL(MSG_MAP_CDIR_ELSE),
                            MSG_ORIG(MSG_STR_CDIR_ELIF),
                            EC_LINENO(level->cdl_else_lineno));
                        return (FALSE);
                }

                /*
                 * Accept text from $elif if the level isn't already
                 * done and the expression evaluates to true.
                 */
                level->cdl_pass = !level->cdl_done && expr_eval;
                if (level->cdl_pass)
                        level->cdl_done = 1;
                break;

        case CDIR_T_ELSE:
                /* $else requires an open $if construct */
                if (STACK_IS_EMPTY(lms.lms_cdir_stack)) {
                        mf_fatal(&arg_mf, MSG_INTL(MSG_MAP_CDIR_NOIF),
                            MSG_ORIG(MSG_STR_CDIR_ELSE));
                        return (FALSE);
                }

                /* There can only be one $else in the chain */
                if (level->cdl_else_lineno > 0) {
                        mf_fatal(&arg_mf, MSG_INTL(MSG_MAP_CDIR_ELSE),
                            MSG_ORIG(MSG_STR_CDIR_ELSE),
                            EC_LINENO(level->cdl_else_lineno));
                        return (FALSE);
                }
                level->cdl_else_lineno = arg_mf.mf_lineno;

                /* Accept text from $else if the level isn't already done */
                level->cdl_pass = !level->cdl_done;
                level->cdl_done = 1;
                break;

        case CDIR_T_ENDIF:
                /* $endif requires an open $if construct */
                if (STACK_IS_EMPTY(lms.lms_cdir_stack)) {
                        mf_fatal(&arg_mf, MSG_INTL(MSG_MAP_CDIR_NOIF),
                            MSG_ORIG(MSG_STR_CDIR_ENDIF));
                        return (FALSE);
                }
                if (--lms.lms_cdir_stack.stk_n > 0)
                        level = &STACK_TOP(lms.lms_cdir_stack);
                break;

        default:
                return (FALSE);
        }

        /* Evaluating the control directive above can change pass status */
        expr_eval = STACK_IS_EMPTY(lms.lms_cdir_stack) ||
            STACK_TOP(lms.lms_cdir_stack).cdl_pass;
        if (expr_eval != pass) {
                pass = expr_eval;
                DBG_CALL(Dbg_map_pass(arg_mf.mf_ofl->ofl_lml, pass,
                    arg_mf.mf_name, arg_mf.mf_lineno, mdptr->md_name));
        }

        /*
         * At this point, we have processed a control directive,
         * updated our conditional state stack, and the input is
         * positioned at the start of the line following the directive.
         * If the current level is accepting input, then give control
         * back to ld_map_gettoken() to resume its normal operation.
         */
        if (pass)
                return (TRUE);

        /*
         * The current level is not accepting input. Only another
         * control directive can change this, so read and discard input
         * until we encounter one of the following:
         *
         * EOF:                 Return and let ld_map_gettoken() report it
         * Control Directive:   Restart this function / evaluate new directive
         */
        while (*mf->mf_next != '\0') {
                /* Skip leading whitespace */
                while (isspace_nonl(*mf->mf_next))
                        mf->mf_next++;

                /*
                 * Control directives start with a '$'. If we hit
                 * one, restart the function at this point
                 */
                if (*mf->mf_next == '$')
                        goto restart;

                /* Not a control directive, so advance input to next line */
                advance_to_eol(&mf->mf_next);
                if (*mf->mf_next == '\n') {
                        mf->mf_lineno++;
                        mf->mf_next++;
                }
        }

        assert(*mf->mf_next == '\0');
        return (TRUE);

        /*
         * Control directives that require an argument that is not present
         * jump here to report the error and exit.
         */
error_reqarg:
        mf_fatal(&arg_mf, MSG_INTL(MSG_MAP_CDIR_REQARG), mdptr->md_name);
        return (FALSE);

}

#ifndef _ELF64
/*
 * Convert a string to lowercase.
 */
void
ld_map_lowercase(char *str)
{
        while (*str = tolower(*str))
                str++;
}
#endif

/*
 * Wrappper on strtoul()/strtoull(), adapted to return an Xword.
 *
 * entry:
 *      str - Pointer to string to be converted.
 *      endptr - As documented for strtoul(3C). Either NULL, or
 *              address of pointer to receive the address of the first
 *              unused character in str (called "final" in strtoul(3C)).
 *      ret_value - Address of Xword variable to receive result.
 *
 * exit:
 *      On success, *ret_value receives the result, *endptr is updated if
 *      endptr is non-NULL, and STRTOXWORD_OK is returned.
 *      On failure, STRTOXWORD_TOBIG is returned if an otherwise valid
 *      value was too large, and STRTOXWORD_BAD is returned if the string
 *      is malformed.
 */
ld_map_strtoxword_t
ld_map_strtoxword(const char *restrict str, char **restrict endptr,
    Xword *ret_value)
{
#if     defined(_ELF64)                 /* _ELF64 */
#define FUNC            strtoull        /* Function to use */
#define FUNC_MAX        ULLONG_MAX      /* Largest value returned by FUNC */
#define XWORD_MAX       ULLONG_MAX      /* Largest Xword value */
        uint64_t        value;          /* Variable of FUNC return type  */
#else                                   /* _ELF32 */
#define FUNC            strtoul
#define FUNC_MAX        ULONG_MAX
#define XWORD_MAX       UINT_MAX
        ulong_t         value;
#endif

        char    *endptr_local;          /* Used if endptr is NULL */

        if (endptr == NULL)
                endptr = &endptr_local;

        errno = 0;
        value = FUNC(str, endptr, 0);
        if ((errno != 0) || (str == *endptr)) {
                if (value  == FUNC_MAX)
                        return (STRTOXWORD_TOOBIG);
                else
                        return (STRTOXWORD_BAD);
        }

        /*
         * If this is a 64-bit linker building an ELFCLASS32 object,
         * the FUNC return type is a 64-bit value, while an Xword is
         * 32-bit. It is possible for FUNC to be able to convert a value
         * too large for our return type.
         */
#if FUNC_MAX != XWORD_MAX
        if (value > XWORD_MAX)
                return (STRTOXWORD_TOOBIG);
#endif

        *ret_value = value;
        return (STRTOXWORD_OK);

#undef FUNC
#undef FUNC_MAX
#undef XWORD_MAC
}

/*
 * Convert the unsigned integer value at the current mapfile input
 * into binary form. All numeric values in mapfiles are treated as
 * unsigned integers of the appropriate width for an address on the
 * given target. Values can be decimal, hex, or octal.
 *
 * entry:
 *      str - String to process.
 *      value - Address of variable to receive resulting value.
 *      notail - If TRUE, an error is issued if non-whitespace
 *              characters other than '#' (comment) are found following
 *              the numeric value before the end of line.
 *
 * exit:
 *      On success:
 *              - *str is advanced to the next character following the value
 *              - *value receives the value
 *              - Returns TRUE (1).
 *      On failure, returns FALSE (0).
 */
static Boolean
ld_map_getint(Mapfile *mf, ld_map_tkval_t *value, Boolean notail)
{
        ld_map_strtoxword_t     s2xw_ret;
        ld_map_npatch_t np;
        char            *endptr;
        char            *errstr = mf->mf_next;

        value->tkv_int.tkvi_str = mf->mf_next;
        s2xw_ret = ld_map_strtoxword(mf->mf_next, &endptr,
            &value->tkv_int.tkvi_value);
        if (s2xw_ret != STRTOXWORD_OK) {
                null_patch_eol(mf->mf_next, &np);
                if (s2xw_ret == STRTOXWORD_TOOBIG)
                        mf_fatal(mf, MSG_INTL(MSG_MAP_VALUELIMIT), errstr);
                else
                        mf_fatal(mf, MSG_INTL(MSG_MAP_MALVALUE), errstr);
                null_patch_undo(&np);
                return (FALSE);
        }

        /* Advance position to item following value, skipping whitespace */
        value->tkv_int.tkvi_cnt = endptr - mf->mf_next;
        mf->mf_next = endptr;
        while (isspace_nonl(*mf->mf_next))
                mf->mf_next++;

        /* If requested, ensure there's nothing left */
        if (notail && (*mf->mf_next != '\n') && (*mf->mf_next != '#') &&
            (*mf->mf_next != '\0')) {
                null_patch_eol(mf->mf_next, &np);
                mf_fatal(mf, MSG_INTL(MSG_MAP_BADVALUETAIL), errstr);
                null_patch_undo(&np);
                return (FALSE);
        }

        return (TRUE);
}

/*
 * Convert a an unquoted identifier into a TK_STRING token, using the
 * rules for syntax version in use. Used exclusively by ld_map_gettoken().
 *
 * entry:
 *      mf - Mapfile descriptor, positioned to the first character of
 *              the string.
 *      flags - Bitmask of options to control ld_map_gettoken()s behavior
 *      tkv- Address of pointer to variable to receive token value.
 *
 * exit:
 *      On success, mf is advanced past the token, tkv is updated with
 *      the string, and TK_STRING is returned. On error, TK_ERROR is returned.
 */
inline static Token
gettoken_ident(Mapfile *mf, int flags, ld_map_tkval_t *tkv)
{
        char    *end;
        Token   tok;
        ld_map_npatch_t np;

        tkv->tkv_str = mf->mf_next;
        if ((end = ident_delimit(mf)) == NULL)
                return (TK_ERROR);
        mf->mf_next = end;

        /*
         * One advantage of reading the entire mapfile into memory is that
         * we can access the strings within it without having to allocate
         * more memory or make copies. In order to do that, we need to NULL
         * terminate this identifier. That is going to overwrite the
         * following character. The problem this presents is that the next
         * character may well be the first character of a subsequent token.
         * The solution to this is:
         *
         * 1)   Disallow the case where the next character is able to
         *      start a string. This is not legal mapfile syntax anyway,
         *      so catching it here simplifies matters.
         * 2)   Copy the character into the special mf->mf_next_ch
         * 3)   The next call to ld_map_gettoken() checks mf->mf_next_ch,
         *      and if it is non-0, uses it instead of dereferencing the
         *      mf_next pointer.
         */
        tok = (*mf->mf_next & 0x80) ?
            TK_OP_ILLCHR : mf->mf_tokdisp[*mf->mf_next];
        switch (tok) {
        case TK_OP_BADCHR:
                null_patch_eol(mf->mf_next, &np);
                mf_fatal(mf, MSG_INTL(MSG_MAP_BADCHAR), mf->mf_next);
                null_patch_undo(&np);
                return (TK_ERROR);

        case TK_OP_SIMQUOTE:
        case TK_OP_CQUOTE:
        case TK_OP_CDIR:
        case TK_OP_NUM:
        case TK_OP_ID:
                null_patch_eol(mf->mf_next, &np);
                mf_fatal(mf, MSG_INTL(MSG_MAP_WSNEEDED), mf->mf_next);
                null_patch_undo(&np);
                return (TK_ERROR);
        }

        /* Null terminate, saving the replaced character */
        mf->mf_next_ch = *mf->mf_next;
        *mf->mf_next = '\0';

        if (flags & TK_F_STRLC)
                ld_map_lowercase(tkv->tkv_str);
        return (TK_STRING);
}

/*
 * Convert a quoted string into a TK_STRING token, using simple
 * quoting rules:
 *      - Start and end quotes must be present and match
 *      - There are no special characters or escape sequences.
 * This function is used exclusively by ld_map_gettoken().
 *
 * entry:
 *      mf - Mapfile descriptor, positioned to the opening quote character.
 *      flags - Bitmask of options to control ld_map_gettoken()s behavior
 *      tkv- Address of pointer to variable to receive token value.
 *
 * exit:
 *      On success, mf is advanced past the token, tkv is updated with
 *      the string, and TK_STRING is returned. On error, TK_ERROR is returned.
 */
inline static Token
gettoken_simquote_str(Mapfile *mf, int flags, ld_map_tkval_t *tkv)
{
        char    *str, *end;
        char    quote;

        str = mf->mf_next++;
        quote = *str;
        end = mf->mf_next;
        while ((*end != '\0') && (*end != '\n') && (*end != quote))
                end++;
        if (*end != quote) {
                ld_map_npatch_t np;

                null_patch_eol(end, &np);
                mf_fatal(mf, MSG_INTL(MSG_MAP_NOTERM), str);
                null_patch_undo(&np);
                return (TK_ERROR);
        }

        /*
         * end is pointing at the closing quote. We can turn that into NULL
         * termination for the string without needing to restore it later.
         */
        *end = '\0';
        mf->mf_next = end + 1;
        tkv->tkv_str = str + 1;         /* Skip opening quote */
        if (flags & TK_F_STRLC)
                ld_map_lowercase(tkv->tkv_str);
        return (TK_STRING);
}

/*
 * Convert a quoted string into a TK_STRING token, using C string literal
 * quoting rules:
 *      - Start and end quotes must be present and match
 *      - Backslash is an escape, used to introduce  special characters
 * This function is used exclusively by ld_map_gettoken().
 *
 * entry:
 *      mf - Mapfile descriptor, positioned to the opening quote character.
 *      flags - Bitmask of options to control ld_map_gettoken()s behavior
 *      tkv- Address of pointer to variable to receive token value.
 *
 * exit:
 *      On success, mf is advanced past the token, tkv is updated with
 *      the string, and TK_STRING is returned. On error, TK_ERROR is returned.
 */
inline static Token
gettoken_cquote_str(Mapfile *mf, int flags, ld_map_tkval_t *tkv)
{
        char    *str, *cur, *end;
        char    quote;
        int     c;

        /*
         * This function goes through the quoted string and copies
         * it on top of itself, replacing escape sequences with the
         * characters they denote. There is always enough room for this,
         * because escapes are multi-character sequences that are converted
         * to single character results.
         */
        str = mf->mf_next++;
        quote = *str;
        cur = end = mf->mf_next;
        for (c = *end++; (c != '\0') && (c != '\n') && (c != quote);
            c = *end++) {
                if (c == '\\') {
                        c = conv_translate_c_esc(&end);
                        if (c == -1) {
                                mf_fatal(mf, MSG_INTL(MSG_MAP_BADCESC), *end);
                                return (TK_ERROR);
                        }
                }
                *cur++ = c;
        }
        *cur = '\0';            /* terminate the result */
        if (c != quote) {
                ld_map_npatch_t np;

                null_patch_eol(end, &np);
                mf_fatal(mf, MSG_INTL(MSG_MAP_NOTERM), str);
                null_patch_undo(&np);
                return (TK_ERROR);
        }

        /* end is pointing one character past the closing quote */
        mf->mf_next = end;
        tkv->tkv_str = str + 1;         /* Skip opening quote */
        if (flags & TK_F_STRLC)
                ld_map_lowercase(tkv->tkv_str);
        return (TK_STRING);
}

/*
 * Get a token from the mapfile.
 *
 * entry:
 *      mf - Mapfile descriptor
 *      flags - Bitmask of options to control ld_map_gettoken()s behavior
 *      tkv- Address of pointer to variable to receive token value.
 *
 * exit:
 *      Returns one of the TK_* values, to report the result. If the resulting
 *      token has a value (TK_STRING / TK_INT), and tkv is non-NULL, tkv
 *      is filled in with the resulting value.
 */
Token
ld_map_gettoken(Mapfile *mf, int flags, ld_map_tkval_t *tkv)
{
        int             cdir_allow, ch;
        Token           tok;
        ld_map_npatch_t np;

        /*
         * Mapfile control directives all start with a '$' character. However,
         * they are only valid when they are the first thing on a line. That
         * happens on the first call to ld_map_gettoken() for a new a new
         * mapfile, as tracked with lms.lms_cdir_valid, and immediately
         * following each newline seen in the file.
         */
        cdir_allow = lms.lms_cdir_valid;
        lms.lms_cdir_valid = 0;

        /* Cycle through the characters looking for tokens. */
        for (;;) {
                /*
                 * Process the next character. This is normally *mf->mf_next,
                 * but if mf->mf_next_ch is non-0, then it contains the
                 * character, and *mf->mf_next contains a NULL termination
                 * from the TK_STRING token returned on the previous call.
                 *
                 * gettoken_ident() ensures that this is never done to
                 * a character that starts a string.
                 */
                if (mf->mf_next_ch == 0) {
                        ch = *mf->mf_next;
                } else {
                        ch = mf->mf_next_ch;
                        mf->mf_next_ch = 0;     /* Reset */
                }

                /* Map the character to a dispatch action */
                tok = (ch & 0x80) ? TK_OP_ILLCHR : mf->mf_tokdisp[ch];

                /*
                 * Items that require processing are identified as OP tokens.
                 * We process them, and return a result non-OP token.
                 *
                 * Non-OP tokens are single character tokens, and we return
                 * them immediately.
                 */
                switch (tok) {
                case TK_OP_EOF:
                        /* If EOFOK is set, quietly report it as TK_EOF */
                        if ((flags & TK_F_EOFOK) != 0)
                                return (TK_EOF);

                        /* Treat it as a standard error */
                        mf_fatal0(mf, MSG_INTL(MSG_MAP_PREMEOF));
                        return (TK_ERROR);

                case TK_OP_ILLCHR:
                        mf_fatal(mf, MSG_INTL(MSG_MAP_ILLCHAR), ch);
                        mf->mf_next++;
                        return (TK_ERROR);

                case TK_OP_BADCHR:
                        tk_op_badchr:
                        null_patch_eol(mf->mf_next, &np);
                        mf_fatal(mf, MSG_INTL(MSG_MAP_BADCHAR), mf->mf_next);
                        null_patch_undo(&np);
                        mf->mf_next++;
                        return (TK_ERROR);

                case TK_OP_WS:  /* White space */
                        mf->mf_next++;
                        break;

                case TK_OP_NL:  /* White space too, but bump line number. */
                        mf->mf_next++;
                        mf->mf_lineno++;
                        cdir_allow = 1;
                        break;

                case TK_OP_SIMQUOTE:
                        if (flags & TK_F_KEYWORD)
                                goto tk_op_badkwquote;
                        return (gettoken_simquote_str(mf, flags, tkv));

                case TK_OP_CQUOTE:
                        if (flags & TK_F_KEYWORD) {
                        tk_op_badkwquote:
                                null_patch_eol(mf->mf_next, &np);
                                mf_fatal(mf, MSG_INTL(MSG_MAP_BADKWQUOTE),
                                    mf->mf_next);
                                null_patch_undo(&np);
                                mf->mf_next++;
                                return (TK_ERROR);
                        }
                        return (gettoken_cquote_str(mf, flags, tkv));

                case TK_OP_CMT:
                        advance_to_eol(&mf->mf_next);
                        break;

                case TK_OP_CDIR:
                        /*
                         * Control directives are only valid at the start
                         * of a line.
                         */
                        if (!cdir_allow) {
                                null_patch_eol(mf->mf_next, &np);
                                mf_fatal(mf, MSG_INTL(MSG_MAP_CDIR_NOTBOL),
                                    mf->mf_next);
                                null_patch_undo(&np);
                                mf->mf_next++;
                                return (TK_ERROR);
                        }
                        if (!cdir_process(mf))
                                return (TK_ERROR);
                        break;

                case TK_OP_NUM: /* Decimal, hex(0x...), or octal (0...) value */
                        if (!ld_map_getint(mf, tkv, FALSE))
                                return (TK_ERROR);
                        return (TK_INT);

                case TK_OP_ID:          /* Unquoted identifier */
                        return (gettoken_ident(mf, flags, tkv));

                case TK_OP_CEQUAL:      /* += or -= */
                        if (*(mf->mf_next + 1) != '=')
                                goto tk_op_badchr;
                        tok = (ch == '+') ? TK_PLUSEQ : TK_MINUSEQ;
                        mf->mf_next += 2;
                        return (tok);

                default:        /* Non-OP token */
                        mf->mf_next++;
                        return (tok);
                }
        }

        /*NOTREACHED*/
        assert(0);
        return (TK_ERROR);
}

/*
 * Given a token and value returned by ld_map_gettoken(), return a string
 * representation of it suitable for use in an error message.
 *
 * entry:
 *      tok - Token code. Must not be an OP-token
 *      tkv - Token value
 */
const char *
ld_map_tokenstr(Token tok, ld_map_tkval_t *tkv, Conv_inv_buf_t *inv_buf)
{
        size_t  cnt;

        switch (tok) {
        case TK_ERROR:
                return (MSG_ORIG(MSG_STR_ERROR));
        case TK_EOF:
                return (MSG_ORIG(MSG_STR_EOF));
        case TK_STRING:
                return (tkv->tkv_str);
        case TK_COLON:
                return (MSG_ORIG(MSG_QSTR_COLON));
        case TK_SEMICOLON:
                return (MSG_ORIG(MSG_QSTR_SEMICOLON));
        case TK_EQUAL:
                return (MSG_ORIG(MSG_QSTR_EQUAL));
        case TK_PLUSEQ:
                return (MSG_ORIG(MSG_QSTR_PLUSEQ));
        case TK_MINUSEQ:
                return (MSG_ORIG(MSG_QSTR_MINUSEQ));
        case TK_ATSIGN:
                return (MSG_ORIG(MSG_QSTR_ATSIGN));
        case TK_DASH:
                return (MSG_ORIG(MSG_QSTR_DASH));
        case TK_LEFTBKT:
                return (MSG_ORIG(MSG_QSTR_LEFTBKT));
        case TK_RIGHTBKT:
                return (MSG_ORIG(MSG_QSTR_RIGHTBKT));
        case TK_PIPE:
                return (MSG_ORIG(MSG_QSTR_PIPE));
        case TK_INT:
                cnt = tkv->tkv_int.tkvi_cnt;
                if (cnt >= sizeof (inv_buf->buf))
                        cnt = sizeof (inv_buf->buf) - 1;
                (void) memcpy(inv_buf->buf, tkv->tkv_int.tkvi_str, cnt);
                inv_buf->buf[cnt] = '\0';
                return (inv_buf->buf);
        case TK_STAR:
                return (MSG_ORIG(MSG_QSTR_STAR));
        case TK_BANG:
                return (MSG_ORIG(MSG_QSTR_BANG));
        default:
                assert(0);
                break;
        }

        /*NOTREACHED*/
        return (MSG_INTL(MSG_MAP_INTERR));
}

/*
 * Advance the input to the first non-empty line, and determine
 * the mapfile version. The version is specified by the mapfile
 * using a $mapfile_version directive. The original System V
 * syntax lacks this directive, and we use that fact to identify
 * such files. SysV mapfile are implicitly defined to have version 1.
 *
 * entry:
 *      ofl - Output file descriptor
 *      mf - Mapfile block
 *
 * exit:
 *      On success, updates mf->mf_version, and returns TRUE (1).
 *      On failure, returns FALSE (0).
 */
static Boolean
mapfile_version(Mapfile *mf)
{
        char    *line_start = mf->mf_next;
        Boolean cont = TRUE;
        Boolean status = TRUE;  /* Assume success */
        Token   tok;

        mf->mf_version = MFV_SYSV;

        /*
         * Cycle through the characters looking for tokens. Although the
         * true version is not known yet, we use the v2 dispatch table.
         * It contains control directives, which we need for this search,
         * and the other TK_OP_ tokens we will recognize and act on are the
         * same for both tables.
         *
         * It is important not to process any tokens that would lead to
         * a non-OP token:
         *
         * -    The version is required to interpret them
         * -    Our mapfile descriptor is not fully initialized,
         *      attempts to run that code will crash the program.
         */
        while (cont) {
                /* Map the character to a dispatch action */
                tok = (*mf->mf_next & 0x80) ?
                    TK_OP_ILLCHR : gettok_dispatch_v2[*mf->mf_next];

                switch (tok) {
                case TK_OP_WS:  /* White space */
                        mf->mf_next++;
                        break;

                case TK_OP_NL:  /* White space too, but bump line number. */
                        mf->mf_next++;
                        mf->mf_lineno++;
                        break;

                case TK_OP_CMT:
                        advance_to_eol(&mf->mf_next);
                        break;

                case TK_OP_CDIR:
                        /*
                         * Control directives are only valid at the start
                         * of a line. However, as we have not yet seen
                         * a token, we do not need to test for this, and
                         * can safely assume that we are at the start.
                         */
                        if (!strncasecmp(mf->mf_next,
                            MSG_ORIG(MSG_STR_CDIR_MFVER),
                            MSG_STR_CDIR_MFVER_SIZE) &&
                            isspace_nonl(*(mf->mf_next +
                            MSG_STR_CDIR_MFVER_SIZE))) {
                                ld_map_tkval_t  ver;

                                mf->mf_next += MSG_STR_CDIR_MFVER_SIZE + 1;
                                if (!ld_map_getint(mf, &ver, TRUE)) {
                                        status = cont = FALSE;
                                        break;
                                }
                                /*
                                 * Is it a valid version? Note that we
                                 * intentionally do not allow you to
                                 * specify version 1 using the $mapfile_version
                                 * syntax, because that's reserved to version
                                 * 2 and up.
                                 */
                                if ((ver.tkv_int.tkvi_value < 2) ||
                                    (ver.tkv_int.tkvi_value >= MFV_NUM)) {
                                        const char *fmt;

                                        fmt = (ver.tkv_int.tkvi_value < 2) ?
                                            MSG_INTL(MSG_MAP_CDIR_BADVDIR) :
                                            MSG_INTL(MSG_MAP_CDIR_BADVER);
                                        mf_fatal(mf, fmt,
                                            EC_WORD(ver.tkv_int.tkvi_value));
                                        status = cont = FALSE;
                                        break;
                                }
                                mf->mf_version = ver.tkv_int.tkvi_value;
                                cont = FALSE; /* Version recovered. All done */
                                break;
                        }
                        /*
                         * Not a version directive. Reset the current position
                         * to the start of the current line and stop here.
                         * SysV syntax applies.
                         */
                        mf->mf_next = line_start;
                        cont = FALSE;
                        break;

                default:
                        /*
                         * If we see anything else, then stop at this point.
                         * The file has System V syntax (version 1), and the
                         * next token should be interpreted as such.
                         */
                        cont = FALSE;
                        break;
                }
        }

        return (status);
}

/*
 * Parse the mapfile.
 */
Boolean
ld_map_parse(const char *mapfile, Ofl_desc *ofl)
{
        struct stat     stat_buf;       /* stat of mapfile */
        int             mapfile_fd;     /* descriptor for mapfile */
        int             err;
        Mapfile         *mf;            /* Mapfile descriptor */
        size_t          name_len;       /* strlen(mapfile) */

        /*
         * Determine if we're dealing with a file or a directory.
         */
        if (stat(mapfile, &stat_buf) == -1) {
                err = errno;
                ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_SYS_STAT), mapfile,
                    strerror(err));
                return (FALSE);
        }
        if (S_ISDIR(stat_buf.st_mode)) {
                DIR             *dirp;
                struct dirent   *denp;

                /*
                 * Open the directory and interpret each visible file as a
                 * mapfile.
                 */
                if ((dirp = opendir(mapfile)) == NULL)
                        return (TRUE);

                while ((denp = readdir(dirp)) != NULL) {
                        char    path[PATH_MAX];

                        /*
                         * Ignore any hidden filenames.  Construct the full
                         * pathname to the new mapfile.
                         */
                        if (*denp->d_name == '.')
                                continue;
                        (void) snprintf(path, PATH_MAX, MSG_ORIG(MSG_STR_PATH),
                            mapfile, denp->d_name);
                        if (!ld_map_parse(path, ofl))
                                return (FALSE);
                }
                (void) closedir(dirp);
                return (TRUE);
        } else if (!S_ISREG(stat_buf.st_mode)) {
                ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_SYS_NOTREG), mapfile);
                return (FALSE);
        }

        /* Open file */
        if ((mapfile_fd = open(mapfile, O_RDONLY)) == -1) {
                err = errno;
                ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_SYS_OPEN), mapfile,
                    strerror(err));
                return (FALSE);
        }

        /*
         * Allocate enough memory to hold the state block, mapfile name,
         * and mapfile text. Text has alignment 1, so it can follow the
         * state block without padding.
         */
        name_len = strlen(mapfile) + 1;
        mf = libld_malloc(sizeof (*mf) + name_len + stat_buf.st_size + 1);
        if (mf == NULL)
                return (FALSE);
        mf->mf_ofl = ofl;
        mf->mf_name = (char *)(mf + 1);
        (void) strcpy(mf->mf_name, mapfile);
        mf->mf_text = mf->mf_name + name_len;
        if (read(mapfile_fd, mf->mf_text, stat_buf.st_size) !=
            stat_buf.st_size) {
                err = errno;
                ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_SYS_READ), mapfile,
                    strerror(err));
                (void) close(mapfile_fd);
                return (FALSE);
        }
        (void) close(mapfile_fd);
        mf->mf_text[stat_buf.st_size] = '\0';
        mf->mf_next = mf->mf_text;
        mf->mf_lineno = 1;
        mf->mf_next_ch = 0;             /* No "lookahead" character yet */
        mf->mf_ec_insndx = 0;           /* Insert entrace criteria at top */

        /*
         * Read just enough from the mapfile to determine the version,
         * and then dispatch to the appropriate code for further processing
         */
        if (!mapfile_version(mf))
                return (FALSE);

        /*
         * Start and continuation masks for unquoted identifier at this
         * mapfile version level.
         */
        mf->mf_tkid_start = TKID_ATTR_START(mf->mf_version);
        mf->mf_tkid_cont = TKID_ATTR_CONT(mf->mf_version);

        DBG_CALL(Dbg_map_parse(ofl->ofl_lml, mapfile, mf->mf_version));

        switch (mf->mf_version) {
        case MFV_SYSV:
                /* Guidance: Use newer mapfile syntax */
                if (OFL_GUIDANCE(ofl, FLG_OFG_NO_MF))
                        ld_eprintf(ofl, ERR_GUIDANCE,
                            MSG_INTL(MSG_GUIDE_MAPFILE), mapfile);

                mf->mf_tokdisp = gettok_dispatch_v1;
                if (!ld_map_parse_v1(mf))
                        return (FALSE);
                break;

        case MFV_SOLARIS:
                mf->mf_tokdisp = gettok_dispatch_v2;
                STACK_RESET(lms.lms_cdir_stack);

                /*
                 * If the conditional expression identifier tree has not been
                 * initialized, set it up. This is only done on the first
                 * mapfile, because the identifier control directives accumulate
                 * across all the mapfiles.
                 */
                if ((lms.lms_cexp_id == NULL) && !cexp_ident_init())
                        return (FALSE);

                /*
                 * Tell ld_map_gettoken() we will accept a '$' as starting a
                 * control directive on the first call. Normally, they are
                 * only allowed after a newline.
                 */
                lms.lms_cdir_valid = 1;

                if (!ld_map_parse_v2(mf))
                        return (FALSE);

                /* Did we leave any open $if control directives? */
                if (!STACK_IS_EMPTY(lms.lms_cdir_stack)) {
                        while (!STACK_IS_EMPTY(lms.lms_cdir_stack)) {
                                cdir_level_t *level =
                                    &STACK_POP(lms.lms_cdir_stack);

                                mf_fatal(mf, MSG_INTL(MSG_MAP_CDIR_NOEND),
                                    EC_LINENO(level->cdl_if_lineno));
                        }
                        return (FALSE);
                }
                break;
        }

        return (TRUE);
}

/*
 * Sort the segment list. This is necessary if a mapfile has set explicit
 * virtual addresses for segments, or defined a SEGMENT_ORDER directive.
 *
 * Only PT_LOAD segments can be assigned a virtual address.  These segments can
 * be one of two types:
 *
 *  -   Standard segments for text, data or bss.  These segments will have been
 *      inserted before the default text (first PT_LOAD) segment.
 *
 *  -   Empty (reservation) segments.  These segment will have been inserted at
 *      the end of any default PT_LOAD segments.
 *
 * Any standard segments that are assigned a virtual address will be sorted,
 * and as their definitions precede any default PT_LOAD segments, these segments
 * will be assigned sections before any defaults.
 *
 * Any reservation segments are also sorted amoung themselves, as these segments
 * must still follow the standard default segments.
 */
static Boolean
sort_seg_list(Ofl_desc *ofl)
{
        APlist  *sort_segs = NULL, *load_segs = NULL;
        Sg_desc *sgp1;
        Aliste  idx1;
        Aliste  nsegs;


        /*
         * We know the number of elements in the sorted list will be
         * the same as the original, so use this as the initial allocation
         * size for the replacement aplist.
         */
        nsegs = aplist_nitems(ofl->ofl_segs);


        /* Add the items below SGID_TEXT to the list */
        for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp1)) {
                if (sgp1->sg_id >= SGID_TEXT)
                        break;

                if (aplist_append(&sort_segs, sgp1, nsegs) == NULL)
                                return (FALSE);
        }

        /*
         * If there are any SEGMENT_ORDER items, add them, and set their
         * FLG_SG_ORDERED flag to identify them in debug output, and to
         * prevent them from being added again below.
         */
        for (APLIST_TRAVERSE(ofl->ofl_segs_order, idx1, sgp1)) {
                if (aplist_append(&sort_segs, sgp1, nsegs) == NULL)
                        return (FALSE);
                sgp1->sg_flags |= FLG_SG_ORDERED;
        }

        /*
         * Add the loadable segments to another list in sorted order.
         */
        DBG_CALL(Dbg_map_sort_title(ofl->ofl_lml, TRUE));
        for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp1)) {
                DBG_CALL(Dbg_map_sort_seg(ofl->ofl_lml, ELFOSABI_SOLARIS,
                    ld_targ.t_m.m_mach, sgp1));

                /* Only interested in PT_LOAD items not in SEGMENT_ORDER list */
                if ((sgp1->sg_phdr.p_type != PT_LOAD) ||
                    (sgp1->sg_flags & FLG_SG_ORDERED))
                        continue;

                /*
                 * If the loadable segment does not contain a vaddr, simply
                 * append it to the new list.
                 */
                if ((sgp1->sg_flags & FLG_SG_P_VADDR) == 0) {
                        if (aplist_append(&load_segs, sgp1, AL_CNT_SEGMENTS) ==
                            NULL)
                                return (FALSE);

                } else {
                        Aliste          idx2;
                        Sg_desc         *sgp2;
                        int             inserted = 0;

                        /*
                         * Traverse the segment list we are creating, looking
                         * for a segment that defines a vaddr.
                         */
                        for (APLIST_TRAVERSE(load_segs, idx2, sgp2)) {
                                /*
                                 * Any real segments that contain vaddr's need
                                 * to be sorted.  Any reservation segments also
                                 * need to be sorted.  However, any reservation
                                 * segments should be placed after any real
                                 * segments.
                                 */
                                if (((sgp2->sg_flags &
                                    (FLG_SG_P_VADDR | FLG_SG_EMPTY)) == 0) &&
                                    (sgp1->sg_flags & FLG_SG_EMPTY))
                                        continue;

                                if ((sgp2->sg_flags & FLG_SG_P_VADDR) &&
                                    ((sgp2->sg_flags & FLG_SG_EMPTY) ==
                                    (sgp1->sg_flags & FLG_SG_EMPTY))) {
                                        if (sgp1->sg_phdr.p_vaddr ==
                                            sgp2->sg_phdr.p_vaddr) {
                                                ld_eprintf(ofl, ERR_FATAL,
                                                    MSG_INTL(MSG_MAP_SEGSAME),
                                                    sgp1->sg_name,
                                                    sgp2->sg_name);
                                                return (FALSE);
                                        }

                                        if (sgp1->sg_phdr.p_vaddr >
                                            sgp2->sg_phdr.p_vaddr)
                                                continue;
                                }

                                /*
                                 * Insert this segment before the segment on
                                 * the load_segs list.
                                 */
                                if (aplist_insert(&load_segs, sgp1,
                                    AL_CNT_SEGMENTS, idx2) == NULL)
                                        return (FALSE);
                                inserted = 1;
                                break;
                        }

                        /*
                         * If the segment being inspected has not been inserted
                         * in the segment list, simply append it to the list.
                         */
                        if ((inserted == 0) && (aplist_append(&load_segs,
                            sgp1, AL_CNT_SEGMENTS) == NULL))
                                return (FALSE);
                }
        }

        /*
         * Add the sorted loadable segments to our initial segment list.
         */
        for (APLIST_TRAVERSE(load_segs, idx1, sgp1)) {
                if (aplist_append(&sort_segs, sgp1, AL_CNT_SEGMENTS) == NULL)
                        return (FALSE);
        }

        /*
         * Add all other segments to our list.
         */
        for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp1)) {
                if ((sgp1->sg_id < SGID_TEXT) ||
                    (sgp1->sg_phdr.p_type == PT_LOAD) ||
                    (sgp1->sg_flags & FLG_SG_ORDERED))
                        continue;

                if (aplist_append(&sort_segs, sgp1, AL_CNT_SEGMENTS) == NULL)
                        return (FALSE);
        }

        /*
         * Free the original list, and the pt_load list, and use
         * the new list as the segment list.
         */
        free(ofl->ofl_segs);
        if (load_segs) free(load_segs);
        ofl->ofl_segs = sort_segs;

        if (DBG_ENABLED) {
                Dbg_map_sort_title(ofl->ofl_lml, FALSE);
                for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp1)) {
                        Dbg_map_sort_seg(ofl->ofl_lml, ELFOSABI_SOLARIS,
                            ld_targ.t_m.m_mach, sgp1);
                        }
                }

        return (TRUE);
}

/*
 * After all mapfiles have been processed, this routine is used to
 * finish any remaining mapfile related work.
 *
 * exit:
 *      Returns TRUE on success, and FALSE on failure.
 */
Boolean
ld_map_post_process(Ofl_desc *ofl)
{
        Aliste          idx, idx2;
        Is_desc         *isp;
        Sg_desc         *sgp;
        Ent_desc        *enp;
        Sg_desc         *first_seg = NULL;


        DBG_CALL(Dbg_map_post_title(ofl->ofl_lml));

        /*
         * Per-segment processing:
         * -    Identify segments with explicit virtual address
         * -    Details of input and output section order
         */
        for (APLIST_TRAVERSE(ofl->ofl_segs, idx, sgp)) {
                /*
                 * We are looking for segments. Program headers that represent
                 * segments are required to have a non-NULL name pointer,
                 * while that those that do not are required to have a
                 * NULL name pointer.
                 */
                if (sgp->sg_name == NULL)
                        continue;

                /* Remember the first non-disabled segment */
                if ((first_seg == NULL) && !(sgp->sg_flags & FLG_SG_DISABLED))
                        first_seg = sgp;

                /*
                 * If a segment has an explicit virtual address, we will
                 * need to sort the segments.
                 */
                if (sgp->sg_flags & FLG_SG_P_VADDR)
                        ofl->ofl_flags1 |= FLG_OF1_VADDR;

                /*
                 * The FLG_OF_OS_ORDER flag enables the code that does
                 * output section ordering. Set if the segment has
                 * a non-empty output section order list.
                 */
                if (alist_nitems(sgp->sg_os_order) > 0)
                        ofl->ofl_flags |= FLG_OF_OS_ORDER;

                /*
                 * The version 1 and version 2 syntaxes for input section
                 * ordering are different and incompatible enough that we
                 * only allow the use of one or the other for a given segment:
                 *
                 * v1)  The version 1 syntax has the user set the ?O flag on
                 *      the segment. If this is done, all input sections placed
                 *      via an entrance criteria that has a section name are to
                 *      be sorted, using the order of the entrance criteria
                 *      as the sort key.
                 *
                 * v2)  The version 2 syntax has the user specify a name for
                 *      the entry criteria, and then provide a list of entry
                 *      criteria names via the IS_ORDER segment attribute.
                 *      Sections placed via the criteria listed in IS_ORDER
                 *      are sorted, and the others are not.
                 *
                 * Regardless of the syntax version used, the section sorting
                 * code expects the following:
                 *
                 * -    Segments requiring input section sorting have the
                 *      FLG_SG_IS_ORDER flag set
                 *
                 * -    Entrance criteria referencing the segment that
                 *      participate in input section sorting have a non-zero
                 *      sort key in their ec_ordndx field.
                 *
                 * At this point, the following are true:
                 *
                 * -    All entrance criteria have ec_ordndx set to 0.
                 * -    Segments that require the version 1 behavior have
                 *      the FLG_SG_IS_ORDER flag set, and the segments
                 *      sg_is_order list is empty.
                 * -    Segments that require the version 2 behavior do not
                 *      have FLG_SG_IS_ORDER set, and the sg_is_order list is
                 *      non-empty. This list contains the names of the entrance
                 *      criteria that will participate in input section sorting,
                 *      and their relative order in the list provides the
                 *      sort key to use.
                 *
                 * We must detect these two cases, set the FLG_SG_IS_ORDER
                 * flag as necessary, and fill in all entrance criteria
                 * sort keys. If any input section sorting is to be done,
                 * we also set the FLG_OF_IS_ORDER flag on the output descriptor
                 * to enable the code that does that work.
                 */

                /* Version 1: ?O flag? */
                if (sgp->sg_flags & FLG_SG_IS_ORDER) {
                        Word    index = 0;

                        ofl->ofl_flags |= FLG_OF_IS_ORDER;
                        DBG_CALL(Dbg_map_ent_ord_title(ofl->ofl_lml,
                            sgp->sg_name));

                        /*
                         * Give each user defined entrance criteria for this
                         * segment that specifies a section name a
                         * monotonically increasing sort key.
                         */
                        for (APLIST_TRAVERSE(ofl->ofl_ents, idx2, enp))
                                if ((enp->ec_segment == sgp) &&
                                    (enp->ec_is_name != NULL) &&
                                    ((enp->ec_flags & FLG_EC_BUILTIN) == 0))
                                        enp->ec_ordndx = ++index;
                        continue;
                }

                /* Version 2: SEGMENT IS_ORDER list? */
                if (aplist_nitems(sgp->sg_is_order) > 0) {
                        Word    index = 0;

                        ofl->ofl_flags |= FLG_OF_IS_ORDER;
                        DBG_CALL(Dbg_map_ent_ord_title(ofl->ofl_lml,
                            sgp->sg_name));

                        /*
                         * Give each entrance criteria in the sg_is_order
                         * list a monotonically increasing sort key.
                         */
                        for (APLIST_TRAVERSE(sgp->sg_is_order, idx2, enp)) {
                                enp->ec_ordndx = ++index;
                                enp->ec_segment->sg_flags |= FLG_SG_IS_ORDER;
                        }
                }
        }

        /* Sort the segment descriptors if necessary */
        if (((ofl->ofl_flags1 & FLG_OF1_VADDR) ||
            (aplist_nitems(ofl->ofl_segs_order) > 0)) &&
            !sort_seg_list(ofl))
                return (FALSE);

        /*
         * If the output file is a static file without an interpreter, and
         * if any virtual address is specified, then set the NOHDR flag for
         * backward compatibility.
         */
        if (!(ofl->ofl_flags & (FLG_OF_DYNAMIC | FLG_OF_RELOBJ)) &&
            !(ofl->ofl_osinterp) && (ofl->ofl_flags1 & FLG_OF1_VADDR))
                ofl->ofl_dtflags_1 |= DF_1_NOHDR;

        if (ofl->ofl_flags & FLG_OF_RELOBJ) {
                /*
                 * NOHDR has no effect on a relocatable file.
                 * Make sure this flag isn't set.
                 */
                ofl->ofl_dtflags_1 &= ~DF_1_NOHDR;
        } else if (first_seg != NULL) {
                /*
                 * DF_1_NOHDR might have been set globally by the HDR_NOALLOC
                 * directive. If not, then we want to check the per-segment
                 * flag for the first loadable segment and propagate it
                 * if set.
                 */
                if ((ofl->ofl_dtflags_1 & DF_1_NOHDR) == 0) {
                        /*
                         * If we sorted the segments, the first segment
                         * may have changed.
                         */
                        if ((ofl->ofl_flags1 & FLG_OF1_VADDR) ||
                            (aplist_nitems(ofl->ofl_segs_order) > 0)) {
                                for (APLIST_TRAVERSE(ofl->ofl_segs, idx, sgp)) {
                                        if (sgp->sg_name == NULL)
                                                continue;
                                        if ((sgp->sg_flags & FLG_SG_DISABLED) ==
                                            0) {
                                                first_seg = sgp;
                                                break;
                                        }
                                }
                        }

                        /*
                         * If the per-segment NOHDR flag is set on our first
                         * segment, then make it take effect.
                         */
                        if (first_seg->sg_flags & FLG_SG_NOHDR)
                                ofl->ofl_dtflags_1 |= DF_1_NOHDR;
                }

                /*
                 * For executable and shared objects, the first segment must
                 * be loadable unless NOHDR was specified, because the ELF
                 * header must simultaneously lie at offset 0 of the file and
                 * be included in the first loadable segment. This isn't
                 * possible if some other segment type starts the file
                 */
                if (!(ofl->ofl_dtflags_1 & DF_1_NOHDR) &&
                    (first_seg->sg_phdr.p_type != PT_LOAD)) {
                        Conv_inv_buf_t  inv_buf;

                        ld_eprintf(ofl, ERR_FATAL,
                            MSG_INTL(MSG_SEG_FIRNOTLOAD),
                            conv_phdr_type(ELFOSABI_SOLARIS, ld_targ.t_m.m_mach,
                            first_seg->sg_phdr.p_type, 0, &inv_buf),
                            first_seg->sg_name);
                        return (FALSE);
                }
        }

        /*
         * Mapfiles may have been used to create symbol definitions
         * with backing storage.  Although the backing storage is
         * associated with an input section, the association of the
         * section to an output section (and segment) is initially
         * deferred.  Now that all mapfile processing is complete, any
         * entrance criteria requirements have been processed, and
         * these backing storage sections can be associated with the
         * appropriate output section (and segment).
         */
        if (ofl->ofl_maptext || ofl->ofl_mapdata)
                DBG_CALL(Dbg_sec_backing(ofl->ofl_lml));

        for (APLIST_TRAVERSE(ofl->ofl_maptext, idx, isp)) {
                if (ld_place_section(ofl, isp, NULL,
                    ld_targ.t_id.id_text, NULL) == (Os_desc *)S_ERROR)
                        return (FALSE);
        }

        for (APLIST_TRAVERSE(ofl->ofl_mapdata, idx, isp)) {
                if (ld_place_section(ofl, isp, NULL,
                    ld_targ.t_id.id_data, NULL) == (Os_desc *)S_ERROR)
                        return (FALSE);
        }

        return (TRUE);
}