/*
 * 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 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Copyright 2019 Joyent, Inc.
 */

/*
 * Map file parsing, Version 2 syntax (solaris).
 */
#include	<stdio.h>
#include	<unistd.h>
#include	<ctype.h>
#include	<sys/elf_amd64.h>   /* SHF_AMD64_LARGE */
#include	<elfcap.h>
#include	"msg.h"
#include	"_libld.h"
#include	"_map.h"

/*
 * Use a case insensitive string match when looking up capability mask
 * values by name, and omit the AV_ prefix.
 */
#define	ELFCAP_STYLE ELFCAP_STYLE_LC | ELFCAP_STYLE_F_ICMP

/*
 * Signature for functions used to parse top level mapfile directives
 */
typedef Token (*dir_func_t)(Mapfile *mf);

/*
 * Signature for functions used to parse attribute level assignments
 *	mf - Mapfile descriptor
 *	eq_tok - One of the equal tokens (TK_EQUAL, TK_PLUSEQ, TK_MINUSEQ)
 *		or TK_ERROR. See the comment for attr_fmt_t below.
 *	uvalue - An arbitrary pointer "user value" passed by the
 *		caller to parse_attributes() for use by the function.
 */
typedef Token (* attr_func_t)(Mapfile *mf, Token eq_tok, void *uvalue);

/*
 * Signature for gettoken_str() err_func argument. This is a function
 * called to issue an appropriate error message.
 *
 * The gts prefix stands for "Get Token Str"
 */
typedef void (* gts_efunc_t)(Mapfile *mf, Token tok, ld_map_tkval_t *tkv);

/*
 * The attr_fmt_t tells parse_attributes how far to go in parsing
 * an attribute before it calls the at_func function to take over:
 *
 *	ATTR_FMT_NAME - Parse the name, and immediately call the function.
 *		This is useful in cases where there is more than
 *		one possible syntax for a given attribute. The value of
 *		eq_tok passed to the at_func function will be TK_ERROR,
 *		reflecting the fact that it has no meaning in this context.
 *
 *	ATTR_FMT_EQ - Parse the name, and the following '=', and then call
 *		the function. The value passed to the at_func function for
 *		eq_tok will be TK_EQUAL.
 *
 *	ATTR_FMT_EQ_PEQ - Parse the name, and a following equal token which
 *		can be '=' or '+=', and then call the function. The value
 *		passed to the at_func function for eq_tok will be one of
 *		TK_EQUAL, or TK_PLUSEQ.
 *
 *	ATTR_FMT_EQ_ALL - Parse the name, and a following equal token which
 *		can be any of the three forms (=, +=, -=), and then call
 *		the function. The value passed to the at_func function for
 *		eq_tok will be one of TK_EQUAL, TK_PLUSEQ, or TK_MINUSEQ.
 */
typedef enum {
	ATTR_FMT_NAME,
	ATTR_FMT_EQ,
	ATTR_FMT_EQ_PEQ,
	ATTR_FMT_EQ_ALL,
} attr_fmt_t;

/*
 * Type used to describe a set of valid attributes to parse_attributes():
 *	at_name - Name of attribute
 *	at_func - Function to call when attribute is recognized,
 *	at_all_eq - True if attribute allows the '+=' and '-=' forms of
 *		assignment token, and False to only allow '='.
 *
 * The array of these structs passed to parse_attributes() must be
 * NULL terminated (the at_name field must be set to NULL).
 */
typedef struct {
	const char	*at_name;	/* Name of attribute */
	attr_func_t	at_func;	/* Function to call */
	attr_fmt_t	at_fmt;		/* How much to parse before calling */
					/*	at_func */
} attr_t;

/*
 * Mapfile version and symbol state are separate but related concepts
 * that are best represented using two different types. However, our
 * style of passing a single uvalue via parse_attributes() makes it
 * convenient to be able to reference them from a single address.
 */
typedef struct {
	ld_map_ver_t	ss_mv;
	ld_map_sym_t	ss_ms;
	Ass_desc	ss_ma;
} symbol_state_t;

/*
 * Process an expected equal operator. Deals with the fact that we
 * have three variants.
 *
 * entry:
 *	mf - Mapfile descriptor
 *	eq_type - Types of equal operators accepted. One of ATTR_FMT_EQ,
 *		ATTR_FMT_EQ_PEQ, or ATTR_FMT_EQ_ALL.
 *	lhs - Name that appears on the left hand side of the expected
 *		equal operator.
 *
 * exit:
 *	Returns one of TK_EQUAL, TK_PLUSEQ, TK_MINUSEQ, or TK_ERROR.
 */
static Token
gettoken_eq(Mapfile *mf, attr_fmt_t eq_type, const char *lhs)
{
	Token		tok;
	ld_map_tkval_t	tkv;
	const char	*err;
	Conv_inv_buf_t	inv_buf;

	switch (tok = ld_map_gettoken(mf, 0, &tkv)) {
	case TK_ERROR:
	case TK_EQUAL:
		return (tok);

	case TK_PLUSEQ:
		switch (eq_type) {
		case ATTR_FMT_EQ_PEQ:
		case ATTR_FMT_EQ_ALL:
			return (tok);
		}
		break;

	case TK_MINUSEQ:
		if (eq_type == ATTR_FMT_EQ_ALL)
			return (tok);
		break;
	}

	switch (eq_type) {
	case ATTR_FMT_EQ:
		err = MSG_INTL(MSG_MAP_EXP_EQ);
		break;
	case ATTR_FMT_EQ_PEQ:
		err = MSG_INTL(MSG_MAP_EXP_EQ_PEQ);
		break;
	case ATTR_FMT_EQ_ALL:
		err = MSG_INTL(MSG_MAP_EXP_EQ_ALL);
		break;
	default:
		/*NOTREACHED*/
		assert(0);
	}
	mf_fatal(mf, err, lhs, ld_map_tokenstr(tok, &tkv, &inv_buf));
	return (TK_ERROR);
}

/*
 * Apply one of the three equal tokens to a bitmask value
 *
 * entry:
 *	dst - Address of bitmask variable to alter
 *	eq_tok - One of TK_EQUAL, TK_PLUSEQ, TK_MINUSEQ, representing
 *		the operation to carry out.
 *	value - Value for right hand side
 *
 * exit:
 *	The operation has been carried out:
 *
 *	TK_EQUAL - *dst is set to value
 *	TK_PLUSEQ - Bits in value have been set in *dst
 *	TK_MINUSEQ - Bits in value have been removed from *dst
 */
static void
setflags_eq(Word *dst, Token eq_tok, Word value)
{
	switch (eq_tok) {
	case TK_EQUAL:
		*dst = value;
		break;
	case TK_PLUSEQ:
		*dst |= value;
		break;
	case TK_MINUSEQ:
		*dst &= ~value;
		break;
	default:
		/*NOTREACHED*/
		assert(0);
	}
}

/*
 * Apply one of the three equal tokens to a capabilities Capmask.
 *
 * entry:
 *	mf - Mapfile descriptor
 *	capmask - Address of Capmask variable to alter
 *	eq_tok - One of TK_EQUAL, TK_PLUSEQ, TK_MINUSEQ, representing
 *		the operation to carry out.
 *	type - Capability type (CA_SUNW_*)
 *	value - Value for right hand side
 *	title - True if a title is needed, False otherwise.
 *
 * exit:
 *	On success, returns TRUE (1), otherwise FALSE (0)
 */
static Boolean
set_capmask(Mapfile *mf, Capmask *capmask, Token eq_tok,
    Word type, elfcap_mask_t value, Boolean title)
{
	if (title)
		DBG_CALL(Dbg_cap_mapfile_title(mf->mf_ofl->ofl_lml,
		    mf->mf_lineno));
	DBG_CALL(Dbg_cap_val_entry(mf->mf_ofl->ofl_lml, DBG_STATE_CURRENT,
	    type, capmask->cm_val, ld_targ.t_m.m_mach));

	switch (eq_tok) {
	case TK_EQUAL:
		capmask->cm_val = value;
		capmask->cm_exc = 0;
		ld_map_cap_set_ovflag(mf, type);
		DBG_CALL(Dbg_cap_val_entry(mf->mf_ofl->ofl_lml,
		    DBG_STATE_RESET, type, capmask->cm_val,
		    ld_targ.t_m.m_mach));
		break;
	case TK_PLUSEQ:
		DBG_CALL(Dbg_cap_val_entry(mf->mf_ofl->ofl_lml,
		    DBG_STATE_ADD, type, value, ld_targ.t_m.m_mach));
		capmask->cm_val |= value;
		capmask->cm_exc &= ~value;
		break;
	case TK_MINUSEQ:
		DBG_CALL(Dbg_cap_val_entry(mf->mf_ofl->ofl_lml,
		    DBG_STATE_EXCLUDE, type, value, ld_targ.t_m.m_mach));
		capmask->cm_val &= ~value;
		capmask->cm_exc |= value;
		break;
	default:
		/*NOTREACHED*/
		assert(0);
	}

	/* Sanity check the resulting bits */
	if (!ld_map_cap_sanitize(mf, type, capmask))
		return (FALSE);

	/* Report the final configuration */
	DBG_CALL(Dbg_cap_val_entry(mf->mf_ofl->ofl_lml,
	    DBG_STATE_RESOLVED, type, capmask->cm_val, ld_targ.t_m.m_mach));

	return (TRUE);
}

/*
 * Apply one of the three equal tokens to a capabilities Caplist.
 *
 * entry:
 *	mf - Mapfile descriptor
 *	caplist - Address of Caplist variable to alter
 *	eq_tok - One of TK_EQUAL, TK_PLUSEQ, TK_MINUSEQ, representing
 *		the operation to carry out.
 *	type - Capability type (CA_SUNW_*)
 *	str - String for right hand side
 *	title - True if a title is needed, False otherwise.
 *
 * exit:
 *	On success, returns TRUE (1), otherwise FALSE (0)
 */
static Boolean
set_capstr(Mapfile *mf, Caplist *caplist, Token eq_tok,
    Word type, APlist *strs)
{
	Capstr		*capstr;
	Aliste		idx1;
	char		*str;

	DBG_CALL(Dbg_cap_mapfile_title(mf->mf_ofl->ofl_lml, mf->mf_lineno));

	if ((caplist->cl_val == NULL) || (alist_nitems(caplist->cl_val) == 0)) {
		DBG_CALL(Dbg_cap_ptr_entry(mf->mf_ofl->ofl_lml,
		    DBG_STATE_CURRENT, type, NULL));
	} else {
		for (ALIST_TRAVERSE(caplist->cl_val, idx1, capstr)) {
			DBG_CALL(Dbg_cap_ptr_entry(mf->mf_ofl->ofl_lml,
			    DBG_STATE_CURRENT, type, capstr->cs_str));
		}
	}

	switch (eq_tok) {
	case TK_EQUAL:
		if (caplist->cl_val) {
			(void) free(caplist->cl_val);
			caplist->cl_val = NULL;
		}
		if (caplist->cl_exc) {
			(void) free(caplist->cl_exc);
			caplist->cl_exc = NULL;
		}
		if (strs) {
			for (APLIST_TRAVERSE(strs, idx1, str)) {
				if ((capstr = alist_append(&caplist->cl_val,
				    NULL, sizeof (Capstr),
				    AL_CNT_CAP_NAMES)) == NULL)
					return (FALSE);
				capstr->cs_str = str;
				DBG_CALL(Dbg_cap_ptr_entry(mf->mf_ofl->ofl_lml,
				    DBG_STATE_RESET, type, capstr->cs_str));
			}
		} else {
			DBG_CALL(Dbg_cap_ptr_entry(mf->mf_ofl->ofl_lml,
			    DBG_STATE_RESET, type, NULL));
		}
		ld_map_cap_set_ovflag(mf, type);
		break;
	case TK_PLUSEQ:
		for (APLIST_TRAVERSE(strs, idx1, str)) {
			Aliste		idx2;
			const char	*ostr;
			int		found = 0;

			/*
			 * Add this name to the list of names, provided the
			 * name doesn't already exist.
			 */
			for (ALIST_TRAVERSE(caplist->cl_val, idx2, capstr)) {
				if (strcmp(str, capstr->cs_str) == 0) {
					found++;
					break;
				}
			}
			if ((found == 0) && ((capstr =
			    (Capstr *)alist_append(&caplist->cl_val, NULL,
			    sizeof (Capstr), AL_CNT_CAP_NAMES)) == NULL))
				return (FALSE);
			capstr->cs_str = str;

			/*
			 * Remove this name from the list of excluded names,
			 * provided the name already exists.
			 */
			for (APLIST_TRAVERSE(caplist->cl_exc, idx2, ostr)) {
				if (strcmp(str, ostr) == 0) {
					aplist_delete(caplist->cl_exc, &idx2);
					break;
				}
			}
			DBG_CALL(Dbg_cap_ptr_entry(mf->mf_ofl->ofl_lml,
			    DBG_STATE_ADD, type, str));
		}
		break;
	case TK_MINUSEQ:
		for (APLIST_TRAVERSE(strs, idx1, str)) {
			Aliste		idx2;
			const char	*ostr;
			int		found = 0;

			/*
			 * Delete this name from the list of names, provided
			 * the name already exists.
			 */
			for (ALIST_TRAVERSE(caplist->cl_val, idx2, capstr)) {
				if (strcmp(str, capstr->cs_str) == 0) {
					alist_delete(caplist->cl_val, &idx2);
					break;
				}
			}

			/*
			 * Add this name to the list of excluded names,
			 * provided the name already exists.
			 */
			for (APLIST_TRAVERSE(caplist->cl_exc, idx2, ostr)) {
				if (strcmp(str, ostr) == 0) {
					found++;
					break;
				}
			}
			if ((found == 0) && (aplist_append(&caplist->cl_exc,
			    str, AL_CNT_CAP_NAMES) == NULL))
				return (FALSE);

			DBG_CALL(Dbg_cap_ptr_entry(mf->mf_ofl->ofl_lml,
			    DBG_STATE_EXCLUDE, type, str));
		}
		break;
	default:
		/*NOTREACHED*/
		assert(0);
	}

	/* Report the final configuration */
	if ((caplist->cl_val == NULL) || (alist_nitems(caplist->cl_val) == 0)) {
		DBG_CALL(Dbg_cap_ptr_entry(mf->mf_ofl->ofl_lml,
		    DBG_STATE_RESOLVED, type, NULL));
	} else {
		for (ALIST_TRAVERSE(caplist->cl_val, idx1, capstr)) {
			DBG_CALL(Dbg_cap_ptr_entry(mf->mf_ofl->ofl_lml,
			    DBG_STATE_RESOLVED, type, capstr->cs_str));
		}
	}

	return (TRUE);
}

/*
 * Process the next token, which is expected to start an optional
 * nesting of attributes (';' or '{').
 *
 * entry:
 *	mf - Mapfile descriptor
 *	lhs - Name of the directive or attribute being processed.
 *
 * exit:
 *	Returns TK_SEMICOLON or TK_LEFTBKT for success, and TK_ERROR otherwise.
 */
static Token
gettoken_optattr(Mapfile *mf, const char *lhs)
{
	Token		tok;
	ld_map_tkval_t	tkv;
	Conv_inv_buf_t	inv_buf;

	switch (tok = ld_map_gettoken(mf, 0, &tkv)) {
	case TK_ERROR:
	case TK_SEMICOLON:
	case TK_LEFTBKT:
		return (tok);
	}

	mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_SEMLBKT), lhs,
	    ld_map_tokenstr(tok, &tkv, &inv_buf));
	return (TK_ERROR);
}

/*
 * Process the next token, which is expected to be a line terminator
 * (';' or '}').
 *
 * entry:
 *	mf - Mapfile descriptor
 *	lhs - Name of the directive or attribute being processed.
 *
 * exit:
 *	Returns TK_SEMICOLON or TK_RIGHTBKT for success, and TK_ERROR otherwise.
 */
static Token
gettoken_term(Mapfile *mf, const char *lhs)
{
	Token		tok;
	ld_map_tkval_t	tkv;
	Conv_inv_buf_t	inv_buf;

	switch (tok = ld_map_gettoken(mf, 0, &tkv)) {
	case TK_ERROR:
	case TK_SEMICOLON:
	case TK_RIGHTBKT:
		return (tok);
	}

	mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_SEMRBKT), lhs,
	    ld_map_tokenstr(tok, &tkv, &inv_buf));
	return (TK_ERROR);
}

/*
 * Process the next token, which is expected to be a semicolon.
 *
 * entry:
 *	mf - Mapfile descriptor
 *	lhs - Name of the directive or attribute being processed.
 *
 * exit:
 *	Returns TK_SEMICOLON for success, and TK_ERROR otherwise.
 */
static Token
gettoken_semicolon(Mapfile *mf, const char *lhs)
{
	Token		tok;
	ld_map_tkval_t	tkv;
	Conv_inv_buf_t	inv_buf;

	switch (tok = ld_map_gettoken(mf, 0, &tkv)) {
	case TK_ERROR:
	case TK_SEMICOLON:
		return (tok);
	}

	mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_SEM), lhs,
	    ld_map_tokenstr(tok, &tkv, &inv_buf));
	return (TK_ERROR);
}

/*
 * Process the next token, which is expected to be a '{'
 *
 * entry:
 *	mf - Mapfile descriptor
 *	lhs - Name of the item directly to the left of the expected left
 *		bracket.
 *
 * exit:
 *	Returns TK_LEFTBKT for success, and TK_ERROR otherwise.
 */
static Token
gettoken_leftbkt(Mapfile *mf, const char *lhs)
{
	Token		tok;
	ld_map_tkval_t	tkv;
	Conv_inv_buf_t	inv_buf;

	switch (tok = ld_map_gettoken(mf, 0, &tkv)) {
	case TK_ERROR:
	case TK_LEFTBKT:
		return (tok);
	}

	mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_LBKT), lhs,
	    ld_map_tokenstr(tok, &tkv, &inv_buf));
	return (TK_ERROR);
}

/*
 * Process the next token, which is expected to be an integer
 *
 * entry:
 *	mf - Mapfile descriptor
 *	lhs - Name of the directive or attribute being processed.
 *	tkv - Address of token value struct to be filled in
 *
 * exit:
 *	Updates *tkv and returns TK_INT for success, TK_ERROR otherwise.
 */
static Token
gettoken_int(Mapfile *mf, const char *lhs, ld_map_tkval_t *tkv, int flags)
{
	Token		tok;
	Conv_inv_buf_t	inv_buf;
	char		*start = mf->mf_next;

	switch (tok = ld_map_gettoken(mf, flags, tkv)) {
	case TK_ERROR:
		return (tok);
	case TK_STRING:
		if (strcmp(MSG_ORIG(MSG_MAP_ADDRSIZE), tkv->tkv_str) == 0) {
			tkv->tkv_int.tkvi_str = tkv->tkv_str;
			switch (ld_targ.t_m.m_class) {
			case ELFCLASS32:
				tkv->tkv_int.tkvi_value = sizeof (Elf32_Addr);
				break;
			case ELFCLASS64:
				tkv->tkv_int.tkvi_value = sizeof (Elf64_Addr);
				break;
			case ELFCLASSNONE:
				tkv->tkv_int.tkvi_value = 0;
				break;
			default:
				assert(0);
			}
			tkv->tkv_int.tkvi_cnt = MSG_MAP_ADDRSIZE_SIZE;
			tok = TK_INT;
		} else {
			break;
		}
		/* FALLTHROUGH */
	case TK_INT:
		if ((flags & TK_F_MULOK) &&
		    (ld_map_peektoken(mf) == TK_LEFTSQR)) {
			ld_map_tkval_t mltplr;
			Xword oldval;

			/* read the [, which we know must be there */
			(void) ld_map_gettoken(mf, flags, &mltplr);

			if (ld_map_gettoken(mf, flags & ~TK_F_MULOK,
			    &mltplr) != TK_INT) {
				tkv->tkv_int.tkvi_cnt = mf->mf_next - start;
				mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_INT),
				    MSG_ORIG(MSG_QSTR_LEFTSQR),
				    ld_map_tokenstr(TK_INT, tkv, &inv_buf));
				return (TK_ERROR);
			}

			if (ld_map_peektoken(mf) != TK_RIGHTSQR) {
				tkv->tkv_int.tkvi_cnt = mf->mf_next - start;
				mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_RIGHTSQ),
				    ld_map_tokenstr(TK_INT, tkv, &inv_buf));
				return (TK_ERROR);
			}

			/* Read the right ] */
			(void) ld_map_gettoken(mf, flags, NULL);
			tkv->tkv_int.tkvi_cnt = mf->mf_next - start;
			oldval = tkv->tkv_int.tkvi_value;
			tkv->tkv_int.tkvi_value *= mltplr.tkv_int.tkvi_value;

			if ((tkv->tkv_int.tkvi_value /
			    mltplr.tkv_int.tkvi_value) != oldval) {
				mf_fatal(mf, MSG_INTL(MSG_MAP_MULOVERFLOW),
				    tkv->tkv_int.tkvi_value,
				    mltplr.tkv_int.tkvi_value);
				return (TK_ERROR);
			}
		}

		return (tok);
	}
	mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_INT), lhs,
	    ld_map_tokenstr(tok, tkv, &inv_buf));
	return (TK_ERROR);
}

/*
 * Process the next token, which is expected to be a string
 *
 * entry:
 *	mf - Mapfile descriptor
 *	lhs - Name of the directive or attribute being processed.
 *	tkv - Address of token value struct to be filled in
 *	err_func - Function to call if an error occurs
 *
 * exit:
 *	Updates *tkv and returns TK_STRING for success. Calls the
 *	supplied err_func function and returns TK_ERROR otherwise.
 */
static Token
gettoken_str(Mapfile *mf, int flags, ld_map_tkval_t *tkv, gts_efunc_t efunc)
{
	Token		tok;

	switch (tok = ld_map_gettoken(mf, flags, tkv)) {
	case TK_ERROR:
	case TK_STRING:
		return (tok);
	}

	/* User supplied function reports the error */
	(* efunc)(mf, tok, tkv);

	return (TK_ERROR);
}

/*
 * Given a construct of the following common form:
 *
 *	item_name {
 *		attribute = ...;
 *		...
 *	}
 *
 * where the caller has detected the item_name and opening bracket,
 * parse the construct and call the attribute functions for each
 * attribute detected, stopping when the closing '}' is seen.
 *
 * entry:
 *	mf - Mapfile descriptor
 *	item_name - Already detected name of item for which attributes
 *		are being parsed.
 *	attr_list - NULL terminated array of attr_t structures describing the
 *		valid attributes for the item.
 *	expect_str - Comma separated string listing the names of expected
 *		attributes.
 *	uvalue - User value, passed to the attribute functions without
 *		examination by parse_attributes(), usable for maintaining
 *		shared state between the caller and the functions.
 *
 * exit:
 *	parse_attributes() reads the attribute name and equality token,
 *	and then calls the attribute function given by the attr_list array
 *	to handle everything up to and including the terminating ';'.
 *	This continues until the closing '}' is seen.
 *
 *	If everything is successful, TK_RIGHTBKT is returned. Otherwise,
 *	a suitable error is issued and TK_ERROR is returned.
 */
static Token
parse_attributes(Mapfile *mf, const char *item_name, attr_t *attr_list,
    size_t attr_list_bufsize, void *uvalue)
{
	attr_t		*attr;
	Token		tok, op_tok;
	ld_map_tkval_t	tkv;
	int		done;
	int		attr_cnt = 0;
	Conv_inv_buf_t	inv_buf;

	/* Read attributes until the closing '}' is seen */
	for (done = 0; done == 0; ) {
		switch (tok = ld_map_gettoken(mf, TK_F_KEYWORD, &tkv)) {
		case TK_ERROR:
			return (TK_ERROR);

		case TK_STRING:
			attr = ld_map_kwfind(tkv.tkv_str, attr_list,
			    SGSOFFSETOF(attr_t, at_name), sizeof (attr[0]));
			if (attr == NULL)
				goto bad_attr;

			/*
			 * Depending on the value of at_fmt, there are
			 * fout different actions to take:
			 *	ATTR_FMT_NAME - Call at_func function
			 *	ATTR_FMT_EQ - Read and verify a TK_EQUAL
			 *	ATTR_FMT_EQ_PEQ - Read and verify a TK_EQUAL
			 *		or TK_PLUSEQ.
			 *	ATTR_FMT_EQ_ALL - Read/Verify one of the
			 *		three possible equal tokens
			 *		(TK_EQUAL, TK_PLUSEQ, TK_MINUSEQ).
			 */
			if (attr->at_fmt == ATTR_FMT_NAME) {
				/* Arbitrary value to pass to at_func */
				op_tok = TK_ERROR;
			} else {
				/* Read/Verify appropriate equal operator */
				op_tok = gettoken_eq(mf, attr->at_fmt,
				    attr->at_name);
				if (op_tok == TK_ERROR)
					return (TK_ERROR);
			}

			/* Call the associated function */
			switch (tok = attr->at_func(mf, op_tok, uvalue)) {
			default:
				return (TK_ERROR);
			case TK_SEMICOLON:
				break;
			case TK_RIGHTBKT:
				done = 1;
				break;
			}
			attr_cnt++;
			break;

		case TK_RIGHTBKT:
			done = 1;
			break;

		case TK_SEMICOLON:
			break;		/* Ignore empty statement */

		default:
		bad_attr:
			{
				char buf[VLA_SIZE(attr_list_bufsize)];

				mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_ATTR),
				    ld_map_kwnames(attr_list,
				    SGSOFFSETOF(attr_t, at_name),
				    sizeof (attr[0]), buf, attr_list_bufsize),
				    ld_map_tokenstr(tok, &tkv, &inv_buf));
			}
			return (TK_ERROR);
		}
	}

	/* Make sure there was at least one attribute between the {} brackets */
	if (attr_cnt == 0) {
		mf_fatal(mf, MSG_INTL(MSG_MAP_NOATTR), item_name);
		return (TK_ERROR);
	}

	return (tok);
}

/*
 * Read whitespace delimited segment flags from the input and convert into
 * bitmask of PF_ values they represent. Flags are terminated by a semicolon
 * or right bracket.
 *
 * entry:
 *	mf - Mapfile descriptor
 *	flags - Address of variable to be set to resulting flags value
 *
 * exit:
 *	Returns the terminator token (TK_SEMICOLON or TK_LEFTBKT) on success,
 *	and TK_ERROR otherwise.
 */
static Token
parse_segment_flags(Mapfile *mf, Xword *flags)
{
	/*
	 * Map flag names to their values. Since DATA and STACK have
	 * platform dependent values, we have to determine them at runtime.
	 * We indicate this by setting the top bit.
	 */
#define	PF_DATA		0x80000000
#define	PF_STACK	0x80000001
	typedef struct {
		const char	*name;
		Word		value;
	} segflag_t;
	static segflag_t flag_list[] = {
		{ MSG_ORIG(MSG_MAPKW_DATA),	PF_DATA },
		{ MSG_ORIG(MSG_MAPKW_EXECUTE),	PF_X },
		{ MSG_ORIG(MSG_MAPKW_READ),	PF_R },
		{ MSG_ORIG(MSG_MAPKW_STACK),	PF_STACK },
		{ MSG_ORIG(MSG_MAPKW_WRITE),	PF_W },

		/* List must be null terminated */
		{ 0 },
	};

	/*
	 * Size of buffer needed to format the names in flag_list[]. Must
	 * be kept in sync with flag_list.
	 */
	static size_t	flag_list_bufsize =
	    KW_NAME_SIZE(MSG_MAPKW_DATA) +
	    KW_NAME_SIZE(MSG_MAPKW_EXECUTE) +
	    KW_NAME_SIZE(MSG_MAPKW_READ) +
	    KW_NAME_SIZE(MSG_MAPKW_STACK) +
	    KW_NAME_SIZE(MSG_MAPKW_WRITE);

	Token		tok;
	ld_map_tkval_t	tkv;
	segflag_t	*flag;
	size_t		cnt = 0;
	int		done;
	Conv_inv_buf_t	inv_buf;

	*flags = 0;

	/* Read attributes until the ';' terminator is seen */
	for (done = 0; done == 0; ) {
		switch (tok = ld_map_gettoken(mf, TK_F_KEYWORD, &tkv)) {
		case TK_ERROR:
			return (TK_ERROR);

		case TK_STRING:
			flag = ld_map_kwfind(tkv.tkv_str, flag_list,
			    SGSOFFSETOF(segflag_t, name),
			    sizeof (flag_list[0]));
			if (flag == NULL)
				goto bad_flag;
			switch (flag->value) {
			case PF_DATA:
				*flags |= ld_targ.t_m.m_dataseg_perm;
				break;
			case PF_STACK:
				*flags |= ld_targ.t_m.m_stack_perm;
				break;
			default:
				*flags |= flag->value;
			}
			cnt++;
			break;

		case TK_INT:
			/*
			 * Accept 0 for notational convenience, but refuse
			 * any other value. Note that we don't actually have
			 * to set the flags to 0 here, because there are
			 * already initialized to that before the main loop.
			 */
			if (tkv.tkv_int.tkvi_value != 0)
				goto bad_flag;
			cnt++;
			break;

		case TK_SEMICOLON:
		case TK_RIGHTBKT:
			done = 1;
			break;

		default:
		bad_flag:
			{
				char buf[VLA_SIZE(flag_list_bufsize)];

				mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_SEGFLAG),
				    ld_map_kwnames(flag_list,
				    SGSOFFSETOF(segflag_t, name),
				    sizeof (flag[0]), buf, flag_list_bufsize),
				    ld_map_tokenstr(tok, &tkv, &inv_buf));
			}
			return (TK_ERROR);
		}
	}

	/* Make sure there was at least one flag */
	if (cnt == 0) {
		mf_fatal(mf, MSG_INTL(MSG_MAP_NOVALUES),
		    MSG_ORIG(MSG_MAPKW_FLAGS));
		return (TK_ERROR);
	}

	return (tok);

#undef PF_DATA
#undef PF_STACK
}

/*
 * Parse one of the capabilities attributes that corresponds directly to a
 * capabilities bitmask value (CA_SUNW_HW_x, CA_SUNW_SF_xx).  Values can be
 * integers, or symbolic names that correspond to the capabilities mask
 * in question.
 *
 * entry:
 *	mf - Mapfile descriptor
 *	eq_tok - One of TK_EQUAL, TK_PLUSEQ, TK_MINUSEQ, representing
 *		the operation to carry out.
 *	capmask - Capmask from output descriptor for capability being processed.
 *	type - Capability type (CA_SUNW_*)
 *	elfcap_from_str_func - pointer to elfcap-string-to-value function
 *		for capability being processed.
 *
 * exit:
 *	Returns TK_SEMICOLON or TK_RIGHTBKT for success, and TK_ERROR otherwise.
 */
static Token
parse_cap_mask(Mapfile *mf, Token eq_tok, Capmask *capmask,
    Word type, elfcap_from_str_func_t *elfcap_from_str_func)
{
	int		done;
	Token		tok;
	ld_map_tkval_t	tkv;
	Conv_inv_buf_t	inv_buf;
	elfcap_mask_t	value = 0;
	uint64_t	v;

	for (done = 0; done == 0; ) {
		switch (tok = ld_map_gettoken(mf, TK_F_KEYWORD, &tkv)) {
		case TK_ERROR:
			return (TK_ERROR);

		case TK_STRING:
			if ((v = (* elfcap_from_str_func)(ELFCAP_STYLE,
			    tkv.tkv_str, ld_targ.t_m.m_mach)) != 0) {
				value |= v;
				break;
			}
			goto bad_flag;

		case TK_INT:
			value |= tkv.tkv_int.tkvi_value;
			break;

		case TK_SEMICOLON:
		case TK_RIGHTBKT:
			done = 1;
			break;

		default:
		bad_flag:
			mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_CAPMASK),
			    ld_map_tokenstr(tok, &tkv, &inv_buf));
			return (TK_ERROR);
		}
	}

	if (!set_capmask(mf, capmask, eq_tok, type, value, TRUE))
		return (TK_ERROR);
	return (tok);
}

/*
 * Parse one of the capabilities attributes that manages lists of names
 * (CA_SUNW_PLAT and CA_SUNW_MACH).  Values are symbolic names that correspond
 * to the capabilities mask in question.
 *
 * entry:
 *	mf - Mapfile descriptor
 *	eq_tok - One of TK_EQUAL, TK_PLUSEQ, TK_MINUSEQ, representing
 *		the operation to carry out.
 *	caplist - Caplist from output descriptor for capability being processed.
 *	type - Capability type (CA_SUNW_*)
 *
 * exit:
 *	Returns TK_SEMICOLON or TK_RIGHTBKT for success, and TK_ERROR otherwise.
 */
static Token
parse_cap_list(Mapfile *mf, Token eq_tok, Caplist *caplist,
    Word type)
{
	int		done, found;
	Token		tok;
	ld_map_tkval_t	tkv;
	Conv_inv_buf_t	inv_buf;
	APlist		*strs = NULL;
	Aliste		idx;
	const char	*str;

	for (done = 0, found = 0; done == 0; found = 0) {
		switch (tok = ld_map_gettoken(mf, 0, &tkv)) {
		case TK_ERROR:
			return (TK_ERROR);

		case TK_STRING:
			/*
			 * The name is in tkv.tkv_str.  Save this string for
			 * set_capstr() processing, but remove any duplicates.
			 */
			for (APLIST_TRAVERSE(strs, idx, str)) {
				if (strcmp(str, tkv.tkv_str) == 0) {
					found++;
					break;
				}
			}
			if ((found == 0) && (aplist_append(&strs, tkv.tkv_str,
			    AL_CNT_CAP_NAMES) == NULL))
				return (TK_ERROR);
			break;

		case TK_SEMICOLON:
		case TK_RIGHTBKT:
			done = 1;
			break;

		default:
			mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_CAPNAME),
			    ld_map_tokenstr(tok, &tkv, &inv_buf));
			return (TK_ERROR);
		}
	}

	if (!set_capstr(mf, caplist, eq_tok, type, strs))
		return (TK_ERROR);
	return (tok);
}

/*
 * CAPABILITY [capid] { HW = hwcap_flags...
 * -------------------------^
 */
static Token
at_cap_hw(Mapfile *mf, Token eq_tok, void *uvalue)
{
	int		done;
	Token		tok;
	ld_map_tkval_t	tkv;
	Conv_inv_buf_t	inv_buf;
	Word		hw1 = 0, hw2 = 0;
	uint64_t	v;

	for (done = 0; done == 0; ) {
		switch (tok = ld_map_gettoken(mf, TK_F_KEYWORD, &tkv)) {
		case TK_ERROR:
			return (TK_ERROR);

		case TK_STRING:
			if ((v = elfcap_hw1_from_str(ELFCAP_STYLE,
			    tkv.tkv_str, ld_targ.t_m.m_mach)) != 0) {
				hw1 |= v;
				break;
			}
			if ((v = elfcap_hw2_from_str(ELFCAP_STYLE,
			    tkv.tkv_str, ld_targ.t_m.m_mach)) != 0) {
				hw2 |= v;
				break;
			}
			goto bad_flag;

		case TK_SEMICOLON:
		case TK_RIGHTBKT:
			done = 1;
			break;

		default:
		bad_flag:
			mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_CAPHW),
			    ld_map_tokenstr(tok, &tkv, &inv_buf));
			return (TK_ERROR);
		}
	}

	if (!set_capmask(mf, &mf->mf_ofl->ofl_ocapset.oc_hw_1, eq_tok,
	    CA_SUNW_HW_1, hw1, TRUE))
		return (TK_ERROR);
	if (!set_capmask(mf, &mf->mf_ofl->ofl_ocapset.oc_hw_2, eq_tok,
	    CA_SUNW_HW_2, hw2, FALSE))
		return (TK_ERROR);
	return (tok);
}

/*
 * CAPABILITY [capid] { HW_1 = value ;
 * ---------------------------^
 */
static Token
at_cap_hw_1(Mapfile *mf, Token eq_tok, void *uvalue)
{
	return (parse_cap_mask(mf, eq_tok, &mf->mf_ofl->ofl_ocapset.oc_hw_1,
	    CA_SUNW_HW_1, elfcap_hw1_from_str));
}

/*
 * CAPABILITY [capid] { HW_2 = value ;
 * ---------------------------^
 */
static Token
at_cap_hw_2(Mapfile *mf, Token eq_tok, void *uvalue)
{
	return (parse_cap_mask(mf, eq_tok, &mf->mf_ofl->ofl_ocapset.oc_hw_2,
	    CA_SUNW_HW_2, elfcap_hw2_from_str));
}

/*
 * CAPABILITY [capid] { SF = sfcap_flags...
 * -------------------------^
 */
static Token
at_cap_sf(Mapfile *mf, Token eq_tok, void *uvalue)
{
	int		done;
	Token		tok;
	ld_map_tkval_t	tkv;
	Conv_inv_buf_t	inv_buf;
	Word		sf1 = 0;
	uint64_t	v;

	for (done = 0; done == 0; ) {
		switch (tok = ld_map_gettoken(mf, TK_F_KEYWORD, &tkv)) {
		case TK_ERROR:
			return (TK_ERROR);

		case TK_STRING:
			if ((v = elfcap_sf1_from_str(ELFCAP_STYLE,
			    tkv.tkv_str, ld_targ.t_m.m_mach)) != 0) {
				sf1 |= v;
				break;
			}
			goto bad_flag;

		case TK_SEMICOLON:
		case TK_RIGHTBKT:
			done = 1;
			break;

		default:
		bad_flag:
			mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_CAPSF),
			    ld_map_tokenstr(tok, &tkv, &inv_buf));
			return (TK_ERROR);
		}
	}

	if (!set_capmask(mf, &mf->mf_ofl->ofl_ocapset.oc_sf_1, eq_tok,
	    CA_SUNW_SF_1, sf1, TRUE))
		return (TK_ERROR);

	return (tok);
}

/*
 * CAPABILITY [capid] { SF_1 = value ;
 * ---------------------------^
 */
static Token
at_cap_sf_1(Mapfile *mf, Token eq_tok, void *uvalue)
{
	return (parse_cap_mask(mf, eq_tok, &mf->mf_ofl->ofl_ocapset.oc_sf_1,
	    CA_SUNW_SF_1, elfcap_sf1_from_str));
}

/*
 * CAPABILITY [capid] { MACHINE = value ;
 * ------------------------------^
 */
static Token
at_cap_mach(Mapfile *mf, Token eq_tok, void *uvalue)
{
	return (parse_cap_list(mf, eq_tok, &mf->mf_ofl->ofl_ocapset.oc_mach,
	    CA_SUNW_MACH));
}

/*
 * CAPABILITY [capid] { PLATFORM = value ;
 * -------------------------------^
 */
static Token
at_cap_plat(Mapfile *mf, Token eq_tok, void *uvalue)
{
	return (parse_cap_list(mf, eq_tok, &mf->mf_ofl->ofl_ocapset.oc_plat,
	    CA_SUNW_PLAT));
}

/*
 * Top Level Directive:
 *
 * CAPABILITY [capid] { ...
 * ----------^
 */
static Token
dir_capability(Mapfile *mf)
{
	/* CAPABILITY attributes */
	static attr_t attr_list[] = {
		{ MSG_ORIG(MSG_MAPKW_HW),	at_cap_hw, ATTR_FMT_EQ_ALL },
		{ MSG_ORIG(MSG_MAPKW_HW_1),	at_cap_hw_1, ATTR_FMT_EQ_ALL },
		{ MSG_ORIG(MSG_MAPKW_HW_2),	at_cap_hw_2, ATTR_FMT_EQ_ALL },

		{ MSG_ORIG(MSG_MAPKW_MACHINE),	at_cap_mach, ATTR_FMT_EQ_ALL },
		{ MSG_ORIG(MSG_MAPKW_PLATFORM),	at_cap_plat, ATTR_FMT_EQ_ALL },

		{ MSG_ORIG(MSG_MAPKW_SF),	at_cap_sf, ATTR_FMT_EQ_ALL },
		{ MSG_ORIG(MSG_MAPKW_SF_1),	at_cap_sf_1, ATTR_FMT_EQ_ALL },

		/* List must be null terminated */
		{ 0 }
	};

	/*
	 * Size of buffer needed to format the names in attr_list[]. Must
	 * be kept in sync with attr_list.
	 */
	static size_t	attr_list_bufsize =
	    KW_NAME_SIZE(MSG_MAPKW_HW) +
	    KW_NAME_SIZE(MSG_MAPKW_HW_1) +
	    KW_NAME_SIZE(MSG_MAPKW_HW_2) +
	    KW_NAME_SIZE(MSG_MAPKW_MACHINE) +
	    KW_NAME_SIZE(MSG_MAPKW_PLATFORM) +
	    KW_NAME_SIZE(MSG_MAPKW_SF) +
	    KW_NAME_SIZE(MSG_MAPKW_SF_1);

	Capstr		*capstr;
	Token		tok;
	ld_map_tkval_t	tkv;
	Conv_inv_buf_t	inv_buf;

	/*
	 * The first token can be one of:
	 * -	An opening '{'
	 * -	A name, followed by a '{', or a ';'.
	 * Read this initial sequence.
	 */

	switch (tok = ld_map_gettoken(mf, 0, &tkv)) {
	case TK_ERROR:
		return (TK_ERROR);

	case TK_STRING:
		capstr = &mf->mf_ofl->ofl_ocapset.oc_id;

		/*
		 * The ID name is in tkv.tkv_str.  Save this name in the output
		 * capabilities structure.  Note, should multiple ID entries
		 * be encounterd, the last entry wins.
		 */
		DBG_CALL(Dbg_cap_id(mf->mf_ofl->ofl_lml, mf->mf_lineno,
		    capstr->cs_str, tkv.tkv_str));

		capstr->cs_str = tkv.tkv_str;
		mf->mf_ofl->ofl_ocapset.oc_flags |= FLG_OCS_USRDEFID;

		/*
		 * The name can be followed by an opening '{', or a
		 * terminating ';'
		 */
		switch (tok = gettoken_optattr(mf, capstr->cs_str)) {
		case TK_SEMICOLON:
			return (TK_SEMICOLON);
		case TK_LEFTBKT:
			break;
		default:
			return (TK_ERROR);
		}
		break;

	case TK_LEFTBKT:
		/* Directive has no capid, but does supply attributes */
		break;

	default:
		mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_CAPID),
		    MSG_ORIG(MSG_MAPKW_CAPABILITY),
		    ld_map_tokenstr(tok, &tkv, &inv_buf));
		return (TK_ERROR);
	}

	/* Parse the attributes */
	if (parse_attributes(mf, MSG_ORIG(MSG_MAPKW_CAPABILITY),
	    attr_list, attr_list_bufsize, NULL) == TK_ERROR)
		return (TK_ERROR);

	/* Terminating ';' */
	return (gettoken_semicolon(mf, MSG_ORIG(MSG_MAPKW_CAPABILITY)));
}

/*
 * at_dv_allow(): Value for ALLOW= is not a version string
 */
static void
gts_efunc_at_dv_allow(Mapfile *mf, Token tok, ld_map_tkval_t *tkv)
{
	Conv_inv_buf_t	inv_buf;

	mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_VERSION),
	    MSG_ORIG(MSG_MAPKW_ALLOW), ld_map_tokenstr(tok, tkv, &inv_buf));
}

/*
 * DEPEND_VERSIONS object_name { ALLOW = version
 * -------------------------------------^
 */
static Token
at_dv_allow(Mapfile *mf, Token eq_tok, void *uvalue)
{
	ld_map_tkval_t	tkv;

	if (gettoken_str(mf, 0, &tkv, gts_efunc_at_dv_allow) == TK_ERROR)
		return (TK_ERROR);

	/* Enter the version. uvalue points at the Sdf_desc descriptor */
	if (!ld_map_dv_entry(mf, uvalue, FALSE, tkv.tkv_str))
		return (TK_ERROR);

	/* terminator */
	return (gettoken_term(mf, MSG_ORIG(MSG_MAPKW_ALLOW)));
}

/*
 * at_dv_allow(): Value for REQUIRE= is not a version string
 */
static void
gts_efunc_at_dv_require(Mapfile *mf, Token tok, ld_map_tkval_t *tkv)
{
	Conv_inv_buf_t	inv_buf;

	mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_VERSION),
	    MSG_ORIG(MSG_MAPKW_REQUIRE), ld_map_tokenstr(tok, tkv, &inv_buf));
}

/*
 * DEPEND_VERSIONS object_name { REQURE = version
 * --------------------------------------^
 */
static Token
at_dv_require(Mapfile *mf, Token eq_tok, void *uvalue)
{
	ld_map_tkval_t	tkv;

	/* version_name */
	if (gettoken_str(mf, 0, &tkv, gts_efunc_at_dv_require) == TK_ERROR)
		return (TK_ERROR);

	/* Enter the version. uvalue points at the Sdf_desc descriptor */
	if (!ld_map_dv_entry(mf, uvalue, TRUE, tkv.tkv_str))
		return (TK_ERROR);

	/* terminator */
	return (gettoken_term(mf, MSG_ORIG(MSG_MAPKW_REQUIRE)));
}

/*
 * dir_depend_versions(): Expected object name is not present
 */
static void
gts_efunc_dir_depend_versions(Mapfile *mf, Token tok, ld_map_tkval_t *tkv)
{
	Conv_inv_buf_t	inv_buf;

	mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_OBJNAM),
	    MSG_ORIG(MSG_MAPKW_DEPEND_VERSIONS),
	    ld_map_tokenstr(tok, tkv, &inv_buf));
}

/*
 * Top Level Directive:
 *
 * DEPEND_VERSIONS object_name { ATTR = ...
 * ---------------^
 */
static Token
dir_depend_versions(Mapfile *mf)
{
	/* DEPEND_VERSIONS attributes */
	static attr_t attr_list[] = {
		{ MSG_ORIG(MSG_MAPKW_ALLOW),	at_dv_allow,	ATTR_FMT_EQ },
		{ MSG_ORIG(MSG_MAPKW_REQUIRE),	at_dv_require,	ATTR_FMT_EQ },

		/* List must be null terminated */
		{ 0 }
	};

	/*
	 * Size of buffer needed to format the names in attr_list[]. Must
	 * be kept in sync with attr_list.
	 */
	static size_t	attr_list_bufsize =
	    KW_NAME_SIZE(MSG_MAPKW_ALLOW) +
	    KW_NAME_SIZE(MSG_MAPKW_REQUIRE);

	ld_map_tkval_t	tkv;
	Sdf_desc	*sdf;

	/* object_name */
	if (gettoken_str(mf, 0, &tkv, gts_efunc_dir_depend_versions) ==
	    TK_ERROR)
		return (TK_ERROR);

	/* Get descriptor for dependency */
	if ((sdf = ld_map_dv(mf, tkv.tkv_str)) == NULL)
		return (TK_ERROR);

	/* Opening '{' token */
	if (gettoken_leftbkt(mf, tkv.tkv_str) == TK_ERROR)
		return (TK_ERROR);

	/* Parse the attributes */
	if (parse_attributes(mf, MSG_ORIG(MSG_MAPKW_DEPEND_VERSIONS),
	    attr_list, attr_list_bufsize, sdf) == TK_ERROR)
		return (TK_ERROR);

	/* Terminating ';' */
	return (gettoken_semicolon(mf, MSG_ORIG(MSG_MAPKW_DEPEND_VERSIONS)));
}

/*
 * Top Level Directive:
 *
 * HDR_NOALLOC ;
 * -----------^
 */
static Token
dir_hdr_noalloc(Mapfile *mf)
{
	mf->mf_ofl->ofl_dtflags_1 |= DF_1_NOHDR;
	DBG_CALL(Dbg_map_hdr_noalloc(mf->mf_ofl->ofl_lml, mf->mf_lineno));

	/* ';' terminator token */
	return (gettoken_semicolon(mf, MSG_ORIG(MSG_MAPKW_HDR_NOALLOC)));
}

/*
 * Top Level Directive:
 *
 * PHDR_ADD_NULL = cnt ;
 * -------------^
 */
static Token
dir_phdr_add_null(Mapfile *mf)
{
	Sg_desc		*sgp;
	ld_map_tkval_t	tkv;		/* Value of token */

	/* '=' token */
	if (gettoken_eq(mf, ATTR_FMT_EQ,
	    MSG_ORIG(MSG_MAPKW_PHDR_ADD_NULL)) == TK_ERROR)
		return (TK_ERROR);

	/* integer token */
	if (gettoken_int(mf, MSG_ORIG(MSG_MAPKW_PHDR_ADD_NULL), &tkv, 0) ==
	    TK_ERROR)
		return (TK_ERROR);

	while (tkv.tkv_int.tkvi_value-- > 0) {
		if ((sgp = ld_map_seg_alloc(NULL, PT_NULL,
		    FLG_SG_P_TYPE | FLG_SG_EMPTY)) == NULL)
			return (TK_ERROR);
		if (ld_map_seg_insert(mf, DBG_STATE_NEW, sgp, 0) ==
		    SEG_INS_FAIL)
			return (TK_ERROR);
	}

	/* ';' terminator token */
	return (gettoken_semicolon(mf, MSG_ORIG(MSG_MAPKW_PHDR_ADD_NULL)));
}

/*
 * segment_directive segment_name { ALIGN = value
 * ----------------------------------------^
 */
static Token
at_seg_align(Mapfile *mf, Token eq_tok, void *uvalue)
{
	Sg_desc		*sgp = uvalue;
	ld_map_tkval_t	tkv;

	/* value */
	if (gettoken_int(mf, MSG_ORIG(MSG_MAPKW_ALIGN), &tkv, 0) == TK_ERROR)
		return (TK_ERROR);

	sgp->sg_phdr.p_align = tkv.tkv_int.tkvi_value;
	sgp->sg_flags |= FLG_SG_P_ALIGN;

	/* terminator */
	return (gettoken_term(mf, MSG_ORIG(MSG_MAPKW_ALIGN)));
}

/*
 * at_seg_assign_file_basename(): Value for FILE_BASENAME= is not a file name
 */
static void
gts_efunc_at_seg_assign_file_basename(Mapfile *mf, Token tok,
    ld_map_tkval_t *tkv)
{
	Conv_inv_buf_t	inv_buf;

	mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_FILNAM),
	    MSG_ORIG(MSG_MAPKW_FILE_BASENAME),
	    ld_map_tokenstr(tok, tkv, &inv_buf));
}

/*
 * segment_directive segment_name { ASSIGN { FILE_BASENAME = file_name
 * ---------------------------------------------------------^
 */
static Token
at_seg_assign_file_basename(Mapfile *mf, Token eq_tok, void *uvalue)
{
	Ent_desc	*enp = uvalue;
	ld_map_tkval_t	tkv;

	/* file_name */
	if (gettoken_str(mf, 0, &tkv, gts_efunc_at_seg_assign_file_basename) ==
	    TK_ERROR)
		return (TK_ERROR);

	if (!ld_map_seg_ent_files(mf, enp, TYP_ECF_BASENAME, tkv.tkv_str))
		return (TK_ERROR);

	/* terminator */
	return (gettoken_term(mf, MSG_ORIG(MSG_MAPKW_FILE_BASENAME)));
}

/*
 * at_seg_assign_file_objname(): Value for FILE_OBJNAME= is not an object name
 */
static void
gts_efunc_at_seg_assign_file_objname(Mapfile *mf, Token tok,
    ld_map_tkval_t *tkv)
{
	Conv_inv_buf_t	inv_buf;

	mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_OBJNAM),
	    MSG_ORIG(MSG_MAPKW_FILE_OBJNAME),
	    ld_map_tokenstr(tok, tkv, &inv_buf));
}

/*
 * segment_directive segment_name { ASSIGN { FILE_OBJNAME = name
 * --------------------------------------------------------^
 */
static Token
at_seg_assign_file_objname(Mapfile *mf, Token eq_tok, void *uvalue)
{
	Ent_desc	*enp = uvalue;
	ld_map_tkval_t	tkv;

	/* file_objname */
	if (gettoken_str(mf, 0, &tkv, gts_efunc_at_seg_assign_file_objname) ==
	    TK_ERROR)
		return (TK_ERROR);

	if (!ld_map_seg_ent_files(mf, enp, TYP_ECF_OBJNAME, tkv.tkv_str))
		return (TK_ERROR);

	/* terminator */
	return (gettoken_term(mf, MSG_ORIG(MSG_MAPKW_FILE_OBJNAME)));
}

/*
 * at_seg_assign_file_path(): Value for FILE_PATH= is not a file path
 */
static void
gts_efunc_at_seg_assign_file_path(Mapfile *mf, Token tok, ld_map_tkval_t *tkv)
{
	Conv_inv_buf_t	inv_buf;

	mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_FILPATH),
	    MSG_ORIG(MSG_MAPKW_FILE_PATH),
	    ld_map_tokenstr(tok, tkv, &inv_buf));
}

/*
 * segment_directive segment_name { ASSIGN { FILE_PATH = file_path
 * -----------------------------------------------------^
 */
static Token
at_seg_assign_file_path(Mapfile *mf, Token eq_tok, void *uvalue)
{
	Ent_desc	*enp = uvalue;
	ld_map_tkval_t	tkv;

	/* file_path */
	if (gettoken_str(mf, 0, &tkv, gts_efunc_at_seg_assign_file_path) ==
	    TK_ERROR)
		return (TK_ERROR);

	if (!ld_map_seg_ent_files(mf, enp, TYP_ECF_PATH, tkv.tkv_str))
		return (TK_ERROR);

	/* terminator */
	return (gettoken_term(mf, MSG_ORIG(MSG_MAPKW_FILE_PATH)));
}

/*
 * segment_directive segment_name { ASSIGN { FLAGS = ... ;
 * -------------------------------------------------^
 */
static Token
at_seg_assign_flags(Mapfile *mf, Token eq_tok, void *uvalue)
{
	typedef struct {
		const char	*name;
		Word		value;
	} secflag_t;
	static secflag_t flag_list[] = {
		{ MSG_ORIG(MSG_MAPKW_ALLOC),		SHF_ALLOC },
		{ MSG_ORIG(MSG_MAPKW_EXECUTE),		SHF_EXECINSTR },
		{ MSG_ORIG(MSG_MAPKW_WRITE),		SHF_WRITE },
		{ MSG_ORIG(MSG_MAPKW_AMD64_LARGE),	SHF_AMD64_LARGE },

		/* List must be null terminated */
		{ 0 },
	};

	/*
	 * Size of buffer needed to format the names in flag_list[]. Must
	 * be kept in sync with flag_list.
	 */
	static size_t	flag_list_bufsize =
	    KW_NAME_SIZE(MSG_MAPKW_ALLOC) +
	    KW_NAME_SIZE(MSG_MAPKW_EXECUTE) +
	    KW_NAME_SIZE(MSG_MAPKW_WRITE) +
	    KW_NAME_SIZE(MSG_MAPKW_AMD64_LARGE);

	Ent_desc	*enp = uvalue;
	int		bcnt = 0, cnt = 0;
	secflag_t	*flag;
	int		done;
	Token		tok;
	ld_map_tkval_t	tkv;
	Conv_inv_buf_t	inv_buf;

	/* Read and process tokens until the closing terminator is seen */
	for (done = 0; done == 0; ) {
		switch (tok = ld_map_gettoken(mf, 0, &tkv)) {
		case TK_ERROR:
			return (TK_ERROR);

		case TK_BANG:
			/* Ensure ! only specified once per flag */
			if (bcnt != 0) {
				mf_fatal0(mf, MSG_INTL(MSG_MAP_SFLG_ONEBANG));
				return (TK_ERROR);
			}
			bcnt++;
			break;

		case TK_STRING:
			flag = ld_map_kwfind(tkv.tkv_str, flag_list,
			    SGSOFFSETOF(secflag_t, name), sizeof (flag[0]));
			if (flag == NULL)
				goto bad_flag;
			cnt++;
			enp->ec_attrmask |= flag->value;
			if (bcnt == 0)
				enp->ec_attrbits |=  flag->value;
			bcnt = 0;
			break;

		case TK_RIGHTBKT:
		case TK_SEMICOLON:
			done = 1;
			break;

		default:
		bad_flag:
			{
				char buf[VLA_SIZE(flag_list_bufsize)];

				mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_SECFLAG),
				    ld_map_kwnames(flag_list,
				    SGSOFFSETOF(secflag_t, name),
				    sizeof (flag[0]), buf, flag_list_bufsize),
				    ld_map_tokenstr(tok, &tkv, &inv_buf));
			}
			return (TK_ERROR);
		}
	}

	/*
	 * Ensure that a trailing '!' was not left at the end of the line
	 * without a corresponding flag to apply it to.
	 */
	if (bcnt != 0) {
		mf_fatal0(mf, MSG_INTL(MSG_MAP_SFLG_EXBANG));
		return (TK_ERROR);
	}

	/* Make sure there was at least one flag */
	if (cnt == 0) {
		mf_fatal(mf, MSG_INTL(MSG_MAP_NOVALUES),
		    MSG_ORIG(MSG_MAPKW_FLAGS));
		return (TK_ERROR);
	}

	return (tok);		/* Either TK_SEMICOLON or TK_RIGHTBKT */
}

/*
 * at_seg_assign_is_name(): Value for IS_NAME= is not a section name
 */
static void
gts_efunc_at_seg_assign_is_name(Mapfile *mf, Token tok, ld_map_tkval_t *tkv)
{
	Conv_inv_buf_t	inv_buf;

	mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_SECNAM),
	    MSG_ORIG(MSG_MAPKW_IS_NAME), ld_map_tokenstr(tok, tkv, &inv_buf));
}

/*
 * segment_directive segment_name { ASSIGN { IS_NAME = section_name ;
 * ---------------------------------------------------^
 */
static Token
at_seg_assign_is_name(Mapfile *mf, Token eq_tok, void *uvalue)
{
	Ent_desc	*enp = uvalue;
	ld_map_tkval_t	tkv;

	/* section_name */
	if (gettoken_str(mf, 0, &tkv, gts_efunc_at_seg_assign_is_name) ==
	    TK_ERROR)
		return (TK_ERROR);
	enp->ec_is_name = tkv.tkv_str;

	/* terminator */
	return (gettoken_term(mf, MSG_ORIG(MSG_MAPKW_IS_NAME)));
}

/*
 * at_seg_assign_type(): Value for TYPE= is not a section type
 */
static void
gts_efunc_at_seg_assign_type(Mapfile *mf, Token tok, ld_map_tkval_t *tkv)
{
	Conv_inv_buf_t	inv_buf;

	mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_SHTYPE),
	    ld_map_tokenstr(tok, tkv, &inv_buf));
}

/*
 * segment_directive segment_name { ASSIGN { TYPE = section_type ;
 * ------------------------------------------------^
 */
static Token
at_seg_assign_type(Mapfile *mf, Token eq_tok, void *uvalue)
{
	Ent_desc		*enp = uvalue;
	ld_map_tkval_t		tkv;
	conv_strtol_uvalue_t	conv_uvalue;

	/* section type */
	if (gettoken_str(mf, TK_F_KEYWORD, &tkv,
	    gts_efunc_at_seg_assign_type) == TK_ERROR)
		return (TK_ERROR);

	/*
	 * Use the libconv iteration facility to map the given name to
	 * its value. This allows us to keep up with any new sections
	 * without having to change this code.
	 */
	if (conv_iter_strtol_init(tkv.tkv_str, &conv_uvalue) != 0) {
		conv_iter_ret_t	status;

		/* Look at the canonical form */
		status = conv_iter_sec_type(CONV_OSABI_ALL, CONV_MACH_ALL,
		    CONV_FMT_ALT_CF, conv_iter_strtol, &conv_uvalue);

		/* Failing that, look at the normal form */
		if (status != CONV_ITER_DONE)
			(void) conv_iter_sec_type(CONV_OSABI_ALL,
			    CONV_MACH_ALL, CONV_FMT_ALT_NF, conv_iter_strtol,
			    &conv_uvalue);

		/* If we didn't match anything report error */
		if (!conv_uvalue.csl_found) {
			gts_efunc_at_seg_assign_type(mf, TK_STRING, &tkv);
			return (TK_ERROR);
		}
	}

	enp->ec_type = conv_uvalue.csl_value;

	/* terminator */
	return (gettoken_term(mf, MSG_ORIG(MSG_MAPKW_TYPE)));
}

/*
 * segment_directive segment_name { ASSIGN { ...
 * -----------------------------------------^
 */
static Token
at_seg_assign(Mapfile *mf, Token eq_tok, void *uvalue)
{
	/* segment_directive ASSIGN sub-attributes */
	static attr_t attr_list[] = {
		{ MSG_ORIG(MSG_MAPKW_FILE_BASENAME),
		    at_seg_assign_file_basename,	ATTR_FMT_EQ },
		{ MSG_ORIG(MSG_MAPKW_FILE_OBJNAME),
		    at_seg_assign_file_objname,		ATTR_FMT_EQ },
		{ MSG_ORIG(MSG_MAPKW_FILE_PATH),
		    at_seg_assign_file_path,		ATTR_FMT_EQ },
		{ MSG_ORIG(MSG_MAPKW_FLAGS),
		    at_seg_assign_flags,		ATTR_FMT_EQ_ALL },
		{ MSG_ORIG(MSG_MAPKW_IS_NAME),
		    at_seg_assign_is_name,		ATTR_FMT_EQ },
		{ MSG_ORIG(MSG_MAPKW_TYPE),
		    at_seg_assign_type,			ATTR_FMT_EQ },

		/* List must be null terminated */
		{ 0 }
	};

	/*
	 * Size of buffer needed to format the names in attr_list[]. Must
	 * be kept in sync with attr_list.
	 */
	static size_t	attr_list_bufsize =
	    KW_NAME_SIZE(MSG_MAPKW_FILE_BASENAME) +
	    KW_NAME_SIZE(MSG_MAPKW_FILE_PATH) +
	    KW_NAME_SIZE(MSG_MAPKW_FLAGS) +
	    KW_NAME_SIZE(MSG_MAPKW_FILE_OBJNAME) +
	    KW_NAME_SIZE(MSG_MAPKW_IS_NAME) +
	    KW_NAME_SIZE(MSG_MAPKW_TYPE);

	Sg_desc		*sgp = uvalue;
	Token		tok;
	ld_map_tkval_t	tkv;
	Conv_inv_buf_t	inv_buf;
	const char	*name = NULL;
	Ent_desc	*enp;

	/*
	 * ASSIGN takes an optional name, plus attributes are optional,
	 * so expect a name, an opening '{', or a ';'.
	 */
	tok = ld_map_gettoken(mf, 0, &tkv);
	switch (tok) {
	case TK_ERROR:
		return (TK_ERROR);

	case TK_STRING:
		name = tkv.tkv_str;
		tok = ld_map_gettoken(mf, 0, &tkv);
		break;
	}

	/* Add a new entrance criteria descriptor to the segment */
	if ((enp = ld_map_seg_ent_add(mf, sgp, name)) == NULL)
		return (TK_ERROR);

	/* Having handled the name, expect either '{' or ';' */
	switch (tok) {
	default:
		mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_SEMLBKT),
		    MSG_ORIG(MSG_MAPKW_ASSIGN_SECTION),
		    ld_map_tokenstr(tok, &tkv, &inv_buf));
		return (TK_ERROR);
	case TK_ERROR:
		return (TK_ERROR);
	case TK_SEMICOLON:
	case TK_RIGHTBKT:
		/* No attributes: It will match anything */
		enp->ec_flags |= FLG_EC_CATCHALL;
		break;
	case TK_LEFTBKT:
		/* Parse the attributes */
		if (parse_attributes(mf, MSG_ORIG(MSG_MAPKW_ASSIGN_SECTION),
		    attr_list, attr_list_bufsize, enp) == TK_ERROR)
			return (TK_ERROR);

		/* Terminating ';',  or '}' which also terminates caller */
		tok = gettoken_term(mf, MSG_ORIG(MSG_MAPKW_ASSIGN_SECTION));
		if (tok == TK_ERROR)
			return (TK_ERROR);
		break;
	}

	DBG_CALL(Dbg_map_ent(mf->mf_ofl->ofl_lml, enp, mf->mf_ofl,
	    mf->mf_lineno));
	return (tok);
}

/*
 * segment_directive segment_name { DISABLE ;
 * ----------------------------------------^
 */
static Token
at_seg_disable(Mapfile *mf, Token eq_tok, void *uvalue)
{
	Sg_desc		*sgp = uvalue;

	/* If the segment cannot be disabled, issue error */
	if (sgp->sg_flags & FLG_SG_NODISABLE) {
		mf_fatal(mf, MSG_INTL(MSG_MAP_CNTDISSEG), sgp->sg_name);
		return (TK_ERROR);
	}

	/* Disable the segment */
	sgp->sg_flags |= FLG_SG_DISABLED;

	/* terminator */
	return (gettoken_semicolon(mf, MSG_ORIG(MSG_MAPKW_DISABLE)));
}

/*
 * segment_directive segment_name { FLAGS eq-op ...
 * --------------------------------------------^
 *
 * Note that this routine is also used for the STACK directive,
 * as STACK also manipulates a segment descriptor.
 *
 * STACK { FLAGS eq-op ... ;
 * -------------------^
 */
static Token
at_seg_flags(Mapfile *mf, Token eq_tok, void *uvalue)
{
	Sg_desc		*sgp = uvalue;
	Token		tok;
	Xword		flags;

	tok = parse_segment_flags(mf, &flags);
	if (tok == TK_ERROR)
		return (TK_ERROR);

	setflags_eq(&sgp->sg_phdr.p_flags, eq_tok, flags);
	sgp->sg_flags |= FLG_SG_P_FLAGS;

	return (tok);
}

/*
 * segment_directive segment_name { IS_ORDER eq_op value
 * -----------------------------------------------^
 */
static Token
at_seg_is_order(Mapfile *mf, Token eq_tok, void *uvalue)
{
	Sg_desc		*sgp = uvalue;
	Token		tok;
	ld_map_tkval_t	tkv;
	Conv_inv_buf_t	inv_buf;
	int		done;
	Aliste		idx;
	Ent_desc	*enp, *enp2;

	/*
	 * The '=' form of assignment resets the list. The list contains
	 * pointers to our mapfile text, so we do not have to free anything.
	 */
	if (eq_tok == TK_EQUAL)
		aplist_reset(sgp->sg_is_order);

	/*
	 * One or more ASSIGN names, terminated by a semicolon.
	 */
	for (done = 0; done == 0; ) {
		switch (tok = ld_map_gettoken(mf, 0, &tkv)) {
		case TK_ERROR:
			return (TK_ERROR);

		case TK_STRING:
			/*
			 * The referenced entrance criteria must have
			 * already been defined.
			 */
			enp = ld_ent_lookup(mf->mf_ofl, tkv.tkv_str, NULL);
			if (enp == NULL) {
				mf_fatal(mf, MSG_INTL(MSG_MAP_UNKENT),
				    tkv.tkv_str);
				return (TK_ERROR);
			}

			/*
			 * Make sure it's not already on the list
			 */
			for (APLIST_TRAVERSE(sgp->sg_is_order, idx, enp2))
				if (enp == enp2) {
					mf_fatal(mf,
					    MSG_INTL(MSG_MAP_DUP_IS_ORD),
					    tkv.tkv_str);
					return (TK_ERROR);
				}

			/* Put it at the end of the order list */
			if (aplist_append(&sgp->sg_is_order, enp,
			    AL_CNT_SG_IS_ORDER) == NULL)
				return (TK_ERROR);
			break;

		case TK_SEMICOLON:
		case TK_RIGHTBKT:
			done = 1;
			break;

		default:
			mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_ECNAM),
			    ld_map_tokenstr(tok, &tkv, &inv_buf));
			return (TK_ERROR);
		}
	}

	return (tok);
}

/*
 * segment_directive segment_name { MAX_SIZE = value
 * -------------------------------------------^
 */
static Token
at_seg_max_size(Mapfile *mf, Token eq_tok, void *uvalue)
{
	Sg_desc		*sgp = uvalue;
	ld_map_tkval_t	tkv;

	/* value */
	if (gettoken_int(mf, MSG_ORIG(MSG_MAPKW_MAX_SIZE), &tkv, 0) == TK_ERROR)
		return (TK_ERROR);

	sgp->sg_length = tkv.tkv_int.tkvi_value;
	sgp->sg_flags |= FLG_SG_LENGTH;

	/* terminator */
	return (gettoken_term(mf, MSG_ORIG(MSG_MAPKW_MAX_SIZE)));
}

/*
 * segment_directive segment_name { NOHDR ;
 * --------------------------------------^
 */
static Token
at_seg_nohdr(Mapfile *mf, Token eq_tok, void *uvalue)
{
	Sg_desc		*sgp = uvalue;

	/*
	 * Set the nohdr flag on the segment. If this segment is the
	 * first loadable segment, the ELF and program headers will
	 * not be included.
	 *
	 * The HDR_NOALLOC top level directive is preferred. This feature
	 * exists to give 1:1 feature parity with version 1 mapfiles that
	 * use the ?N segment flag and expect it to only take effect
	 * if that segment ends up being first.
	 */
	sgp->sg_flags |= FLG_SG_NOHDR;

	/* terminator */
	return (gettoken_semicolon(mf, MSG_ORIG(MSG_MAPKW_NOHDR)));
}

/*
 * segment_directive segment_name { OS_ORDER eq_op assign_name...
 * -----------------------------------------------^
 */
static Token
at_seg_os_order(Mapfile *mf, Token eq_tok, void *uvalue)
{
	Sg_desc		*sgp = uvalue;
	Token		tok;
	ld_map_tkval_t	tkv;
	Conv_inv_buf_t	inv_buf;
	int		done;

	/*
	 * The '=' form of assignment resets the list. The list contains
	 * pointers to our mapfile text, so we do not have to free anything.
	 */
	if (eq_tok == TK_EQUAL)
		alist_reset(sgp->sg_os_order);

	/*
	 * One or more section names, terminated by a semicolon.
	 */
	for (done = 0; done == 0; ) {
		switch (tok = ld_map_gettoken(mf, 0, &tkv)) {
		case TK_ERROR:
			return (TK_ERROR);

		case TK_STRING:
			if (!ld_map_seg_os_order_add(mf, sgp, tkv.tkv_str))
				return (TK_ERROR);
			break;

		case TK_SEMICOLON:
		case TK_RIGHTBKT:
			done = 1;
			break;

		default:
			mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_SECNAM),
			    ld_map_tokenstr(tok, &tkv, &inv_buf));
			return (TK_ERROR);
		}
	}

	return (tok);
}

/*
 * segment_directive segment_name { PADDR = paddr
 * ----------------------------------------^
 */
static Token
at_seg_paddr(Mapfile *mf, Token eq_tok, void *uvalue)
{
	Sg_desc		*sgp = uvalue, *sgp2;
	Aliste		idx;
	ld_map_tkval_t	tkv;

	/*
	 * Ensure that the segment isn't in the segment order list.
	 */
	for (APLIST_TRAVERSE(mf->mf_ofl->ofl_segs_order, idx, sgp2))
		if (sgp == sgp2) {
			mf_fatal(mf,
			    MSG_INTL(MSG_MAP_CNTADDRORDER), sgp->sg_name);
			return (TK_ERROR);
		}

	/* value */
	if (gettoken_int(mf, MSG_ORIG(MSG_MAPKW_PADDR), &tkv, 0) == TK_ERROR)
		return (TK_ERROR);

	sgp->sg_phdr.p_paddr = tkv.tkv_int.tkvi_value;
	sgp->sg_flags |= FLG_SG_P_PADDR;

	/* terminator */
	return (gettoken_term(mf, MSG_ORIG(MSG_MAPKW_PADDR)));
}

/*
 * segment_directive segment_name { ROUND = value
 * ----------------------------------------^
 */
static Token
at_seg_round(Mapfile *mf, Token eq_tok, void *uvalue)
{
	Sg_desc		*sgp = uvalue;
	ld_map_tkval_t	tkv;

	/* value */
	if (gettoken_int(mf, MSG_ORIG(MSG_MAPKW_ROUND), &tkv, 0) == TK_ERROR)
		return (TK_ERROR);

	sgp->sg_round = tkv.tkv_int.tkvi_value;
	sgp->sg_flags |= FLG_SG_ROUND;

	/* terminator */
	return (gettoken_term(mf, MSG_ORIG(MSG_MAPKW_ROUND)));
}

/*
 * segment_directive segment_name { SIZE_SYMBOL = symbol_name
 * ----------------------------------------------^
 */
static Token
at_seg_size_symbol(Mapfile *mf, Token eq_tok, void *uvalue)
{
	Sg_desc		*sgp = uvalue;
	Token		tok;
	ld_map_tkval_t	tkv;
	Conv_inv_buf_t	inv_buf;
	int		done, cnt = 0;

	/*
	 * One or more symbol names, terminated by a semicolon.
	 */
	for (done = 0; done == 0; ) {
		switch (tok = ld_map_gettoken(mf, 0, &tkv)) {
		case TK_ERROR:
			return (TK_ERROR);

		case TK_STRING:
			if (!ld_map_seg_size_symbol(mf, sgp, eq_tok,
			    tkv.tkv_str))
				return (TK_ERROR);
			cnt++;

			/*
			 * If the operator is TK_EQUAL, turn it into
			 * TK_PLUSEQ for any symbol names after the first.
			 * These additional symbols are added, and are not
			 * replacements for the first one.
			 */
			eq_tok = TK_PLUSEQ;
			break;

		case TK_SEMICOLON:
		case TK_RIGHTBKT:
			done = 1;
			break;

		default:
			mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_SYMNAM),
			    MSG_ORIG(MSG_MAPKW_SIZE_SYMBOL),
			    ld_map_tokenstr(tok, &tkv, &inv_buf));
			return (TK_ERROR);
		}
	}

	/* Make sure there was at least one name */
	if (cnt == 0) {
		mf_fatal(mf, MSG_INTL(MSG_MAP_NOVALUES),
		    MSG_ORIG(MSG_MAPKW_SIZE_SYMBOL));
		return (TK_ERROR);
	}

	return (tok);
}

/*
 * segment_directive segment_name { VADDR = vaddr
 * ----------------------------------------^
 */
static Token
at_seg_vaddr(Mapfile *mf, Token eq_tok, void *uvalue)
{
	Sg_desc		*sgp = uvalue, *sgp2;
	Aliste		idx;
	ld_map_tkval_t	tkv;

	/*
	 * Ensure that the segment isn't in the segment order list.
	 */
	for (APLIST_TRAVERSE(mf->mf_ofl->ofl_segs_order, idx, sgp2))
		if (sgp == sgp2) {
			mf_fatal(mf,
			    MSG_INTL(MSG_MAP_CNTADDRORDER), sgp->sg_name);
			return (TK_ERROR);
		}

	/* value */
	if (gettoken_int(mf, MSG_ORIG(MSG_MAPKW_VADDR), &tkv, 0) == TK_ERROR)
		return (TK_ERROR);

	sgp->sg_phdr.p_vaddr = tkv.tkv_int.tkvi_value;
	sgp->sg_flags |= FLG_SG_P_VADDR;

	/* terminator */
	return (gettoken_term(mf, MSG_ORIG(MSG_MAPKW_VADDR)));
}

/*
 * Top Level Directive:
 *
 * {LOAD|NOTE|NULL}_SEGMENT segment_name { ...
 * ------------------------^
 *
 * Common implementation body for the family of segment directives. These
 * take the same syntax, and share a common subset of attributes. They differ
 * in the type of segments they handle and the specific attributes accepted.
 *
 * entry:
 *	mf - Mapfile descriptor ({LOAD|NOTE|NULL}_SEGMENT)
 *	dir_name - Name of directive.
 *	seg_type - Type of segment (PT_LOAD, PT_NOTE, PT_NULL).
 *	attr_list - NULL terminated attribute array
 *	attr_list_bufsize - Size of required buffer to format all the
 *		names in attr_list.
 *	gts_efunc - Error function to pass to gettoken_str() when trying
 *		to obtain a segment name token.
 */
static Token
dir_segment_inner(Mapfile *mf, const char *dir_name, Word seg_type,
    attr_t *attr_list, size_t attr_list_bufsize, gts_efunc_t gts_efunc)
{
	Token		tok;
	ld_map_tkval_t	tkv;
	Sg_desc		*sgp;
	Boolean		new_segment;
	Xword		ndx;
	avl_index_t	where;

	/* segment_name */
	if (gettoken_str(mf, 0, &tkv, gts_efunc) == TK_ERROR)
		return (TK_ERROR);
	sgp = ld_seg_lookup(mf->mf_ofl, tkv.tkv_str, &where);
	new_segment = (sgp == NULL);

	if (new_segment) {
		/* Allocate a descriptor for new segment */
		if ((sgp = ld_map_seg_alloc(tkv.tkv_str, seg_type,
		    FLG_SG_P_TYPE)) == NULL)
			return (TK_ERROR);
	} else {
		/* Make sure it's the right type of segment */
		if (sgp->sg_phdr.p_type != seg_type) {
			Conv_inv_buf_t	inv_buf;

			mf_fatal(mf, MSG_INTL(MSG_MAP_EXPSEGTYPE),
			    conv_phdr_type(ELFOSABI_SOLARIS, ld_targ.t_m.m_mach,
			    sgp->sg_phdr.p_type, CONV_FMT_ALT_CF, &inv_buf),
			    dir_name, tkv.tkv_str);
			return (TK_ERROR);
		}

		/* If it was disabled, being referenced enables it */
		sgp->sg_flags &= ~FLG_SG_DISABLED;

		if (DBG_ENABLED) {
			/*
			 * Not a new segment, so show the initial value
			 * before modifying it.
			 */
			ndx = ld_map_seg_index(mf, sgp);
			DBG_CALL(Dbg_map_seg(mf->mf_ofl, DBG_STATE_MOD_BEFORE,
			    ndx, sgp, mf->mf_lineno));
		}
	}

	/*
	 * Attributes are optional, so expect an opening '{', or a ';'.
	 */
	switch (tok = gettoken_optattr(mf, dir_name)) {
	default:
		tok = TK_ERROR;
		break;
	case TK_SEMICOLON:
		break;
	case TK_LEFTBKT:
		/* Parse the attributes */
		if (parse_attributes(mf, dir_name,
		    attr_list, attr_list_bufsize, sgp) == TK_ERROR)
			return (TK_ERROR);

		/* Terminating ';' */
		tok = gettoken_semicolon(mf, dir_name);
		if (tok == TK_ERROR)
			return (TK_ERROR);

		break;
	}

	/*
	 * If this is a new segment, finish its initialization
	 * and insert it into the segment list.
	 */
	if (new_segment) {
		if (ld_map_seg_insert(mf, DBG_STATE_NEW, sgp, where) ==
		    SEG_INS_FAIL)
			return (TK_ERROR);
	} else {
		/* Not new. Show what's changed */
		DBG_CALL(Dbg_map_seg(mf->mf_ofl, DBG_STATE_MOD_AFTER,
		    ndx, sgp, mf->mf_lineno));
	}

	return (tok);
}

/*
 * dir_load_segment(): Expected loadable segment name is not present
 */
static void
gts_efunc_dir_load_segment(Mapfile *mf, Token tok, ld_map_tkval_t *tkv)
{
	Conv_inv_buf_t	inv_buf;

	mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_SEGNAM),
	    MSG_ORIG(MSG_MAPKW_LOAD_SEGMENT),
	    ld_map_tokenstr(tok, tkv, &inv_buf));
}

/*
 * Top Level Directive:
 *
 * LOAD_SEGMENT segment_name { ...
 * ------------^
 */
static Token
dir_load_segment(Mapfile *mf)
{
	/* LOAD_SEGMENT attributes */
	static attr_t attr_list[] = {
		{ MSG_ORIG(MSG_MAPKW_ALIGN),	at_seg_align,	ATTR_FMT_EQ },
		{ MSG_ORIG(MSG_MAPKW_ASSIGN_SECTION),
		    at_seg_assign,	ATTR_FMT_NAME },
		{ MSG_ORIG(MSG_MAPKW_DISABLE),	at_seg_disable,	ATTR_FMT_NAME },
		{ MSG_ORIG(MSG_MAPKW_FLAGS),	at_seg_flags,
		    ATTR_FMT_EQ_ALL },
		{ MSG_ORIG(MSG_MAPKW_IS_ORDER),	at_seg_is_order,
		    ATTR_FMT_EQ_PEQ },
		{ MSG_ORIG(MSG_MAPKW_MAX_SIZE),	at_seg_max_size, ATTR_FMT_EQ },
		{ MSG_ORIG(MSG_MAPKW_NOHDR),	at_seg_nohdr,	ATTR_FMT_NAME },
		{ MSG_ORIG(MSG_MAPKW_OS_ORDER),	at_seg_os_order,
		    ATTR_FMT_EQ_PEQ },
		{ MSG_ORIG(MSG_MAPKW_PADDR),	at_seg_paddr,	ATTR_FMT_EQ },
		{ MSG_ORIG(MSG_MAPKW_ROUND),	at_seg_round,	ATTR_FMT_EQ },
		{ MSG_ORIG(MSG_MAPKW_SIZE_SYMBOL),
		    at_seg_size_symbol,	ATTR_FMT_EQ_PEQ },
		{ MSG_ORIG(MSG_MAPKW_VADDR),	at_seg_vaddr,	ATTR_FMT_EQ },

		/* List must be null terminated */
		{ 0 }
	};

	/*
	 * Size of buffer needed to format the names in attr_list[]. Must
	 * be kept in sync with attr_list.
	 */
	static size_t	attr_list_bufsize =
	    KW_NAME_SIZE(MSG_MAPKW_ALIGN) +
	    KW_NAME_SIZE(MSG_MAPKW_ASSIGN_SECTION) +
	    KW_NAME_SIZE(MSG_MAPKW_DISABLE) +
	    KW_NAME_SIZE(MSG_MAPKW_FLAGS) +
	    KW_NAME_SIZE(MSG_MAPKW_IS_ORDER) +
	    KW_NAME_SIZE(MSG_MAPKW_MAX_SIZE) +
	    KW_NAME_SIZE(MSG_MAPKW_PADDR) +
	    KW_NAME_SIZE(MSG_MAPKW_ROUND) +
	    KW_NAME_SIZE(MSG_MAPKW_OS_ORDER) +
	    KW_NAME_SIZE(MSG_MAPKW_SIZE_SYMBOL) +
	    KW_NAME_SIZE(MSG_MAPKW_VADDR);

	return (dir_segment_inner(mf, MSG_ORIG(MSG_MAPKW_LOAD_SEGMENT),
	    PT_LOAD, attr_list, attr_list_bufsize, gts_efunc_dir_load_segment));

}

/*
 * Common shared segment directive attributes
 */
static attr_t segment_core_attr_list[] = {
	{ MSG_ORIG(MSG_MAPKW_ASSIGN_SECTION), at_seg_assign, ATTR_FMT_NAME },
	{ MSG_ORIG(MSG_MAPKW_DISABLE),	at_seg_disable,	 ATTR_FMT_NAME },
	{ MSG_ORIG(MSG_MAPKW_IS_ORDER),	at_seg_is_order, ATTR_FMT_EQ_PEQ },
	{ MSG_ORIG(MSG_MAPKW_OS_ORDER),	at_seg_os_order, ATTR_FMT_EQ_PEQ },

	/* List must be null terminated */
	{ 0 }
};

/*
 * Size of buffer needed to format the names in segment_core_attr_list[].
 * Must be kept in sync with segment_core_attr_list.
 */
static size_t	segment_core_attr_list_bufsize =
	KW_NAME_SIZE(MSG_MAPKW_ASSIGN_SECTION) +
	KW_NAME_SIZE(MSG_MAPKW_DISABLE) +
	KW_NAME_SIZE(MSG_MAPKW_IS_ORDER) +
	KW_NAME_SIZE(MSG_MAPKW_OS_ORDER);

/*
 * dir_note_segment(): Expected note segment name is not present
 */
static void
gts_efunc_dir_note_segment(Mapfile *mf, Token tok, ld_map_tkval_t *tkv)
{
	Conv_inv_buf_t	inv_buf;

	mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_SEGNAM),
	    MSG_ORIG(MSG_MAPKW_NOTE_SEGMENT),
	    ld_map_tokenstr(tok, tkv, &inv_buf));
}

/*
 * Top Level Directive:
 *
 * NOTE_SEGMENT segment_name { ...
 * ------------^
 */
static Token
dir_note_segment(Mapfile *mf)
{
	return (dir_segment_inner(mf, MSG_ORIG(MSG_MAPKW_NOTE_SEGMENT),
	    PT_NOTE, segment_core_attr_list, segment_core_attr_list_bufsize,
	    gts_efunc_dir_note_segment));

}

/*
 * dir_null_segment(): Expected null segment name is not present
 */
static void
gts_efunc_dir_null_segment(Mapfile *mf, Token tok, ld_map_tkval_t *tkv)
{
	Conv_inv_buf_t	inv_buf;

	mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_SEGNAM),
	    MSG_ORIG(MSG_MAPKW_NULL_SEGMENT),
	    ld_map_tokenstr(tok, tkv, &inv_buf));
}

/*
 * Top Level Directive:
 *
 * NULL_SEGMENT segment_name { ...
 * ------------^
 */
static Token
dir_null_segment(Mapfile *mf)
{
	return (dir_segment_inner(mf, MSG_ORIG(MSG_MAPKW_NULL_SEGMENT),
	    PT_NULL, segment_core_attr_list, segment_core_attr_list_bufsize,
	    gts_efunc_dir_null_segment));

}

/*
 * Top Level Directive:
 *
 * SEGMENT_ORDER segment_name ... ;
 */
static Token
dir_segment_order(Mapfile *mf)
{
	Token		tok;
	ld_map_tkval_t	tkv;
	Conv_inv_buf_t	inv_buf;
	Aliste		idx;
	Sg_desc		*sgp, *sgp2;
	int		done;

	/* Expect either a '=' or '+=' */
	tok = gettoken_eq(mf, ATTR_FMT_EQ_PEQ,
	    MSG_ORIG(MSG_MAPKW_SEGMENT_ORDER));
	if (tok == TK_ERROR)
		return (TK_ERROR);

	DBG_CALL(Dbg_map_seg_order(mf->mf_ofl, ELFOSABI_SOLARIS,
	    ld_targ.t_m.m_mach, DBG_STATE_MOD_BEFORE, mf->mf_lineno));

	/*
	 * The '=' form of assignment resets the list. The list contains
	 * pointers to our mapfile text, so we do not have to free anything.
	 */
	if (tok == TK_EQUAL)
		aplist_reset(mf->mf_ofl->ofl_segs_order);

	/* Read segment names, and add to list until terminator (';') is seen */
	for (done = 0; done == 0; ) {
		switch (tok = ld_map_gettoken(mf, 0, &tkv)) {
		case TK_ERROR:
			return (TK_ERROR);

		case TK_STRING:
			/*
			 * The segment must have already been defined.
			 */
			sgp = ld_seg_lookup(mf->mf_ofl, tkv.tkv_str, NULL);
			if (sgp == NULL) {
				mf_fatal(mf, MSG_INTL(MSG_MAP_UNKSEG),
				    tkv.tkv_str);
				return (TK_ERROR);
			}

			/*
			 * Make sure it's not already on the list
			 */
			for (APLIST_TRAVERSE(mf->mf_ofl->ofl_segs_order,
			    idx, sgp2))
				if (sgp == sgp2) {
					mf_fatal(mf,
					    MSG_INTL(MSG_MAP_DUPORDSEG),
					    MSG_ORIG(MSG_MAPKW_SEGMENT_ORDER),
					    tkv.tkv_str);
					return (TK_ERROR);
				}

			/*
			 * It can't be ordered and also have an explicit
			 * paddr or vaddr.
			 */
			if (sgp->sg_flags & (FLG_SG_P_PADDR | FLG_SG_P_VADDR)) {
				mf_fatal(mf, MSG_INTL(MSG_MAP_CNTADDRORDER),
				    sgp->sg_name);
				return (TK_ERROR);
			}


			/* Put it at the end of the list */
			if (aplist_append(&mf->mf_ofl->ofl_segs_order, sgp,
			    AL_CNT_SG_IS_ORDER) == NULL)
				return (TK_ERROR);
			break;

		case TK_SEMICOLON:
			done = 1;
			break;

		default:
			mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_SEGNAM),
			    MSG_ORIG(MSG_MAPKW_SEGMENT_ORDER),
			    ld_map_tokenstr(tok, &tkv, &inv_buf));
			return (TK_ERROR);
		}
	}

	DBG_CALL(Dbg_map_seg_order(mf->mf_ofl, ELFOSABI_SOLARIS,
	    ld_targ.t_m.m_mach, DBG_STATE_MOD_AFTER, mf->mf_lineno));

	return (tok);
}

/*
 * Top Level Directive:
 *
 * STACK { ...
 * -----^
 */
static Token
dir_stack(Mapfile *mf)
{
	/* STACK attributes */
	static attr_t attr_list[] = {
		{ MSG_ORIG(MSG_MAPKW_FLAGS), at_seg_flags, ATTR_FMT_EQ_ALL },

		/* List must be null terminated */
		{ 0 }
	};

	/*
	 * Size of buffer needed to format the names in attr_list[]. Must
	 * be kept in sync with attr_list.
	 */
	static size_t	attr_list_bufsize =
	    KW_NAME_SIZE(MSG_MAPKW_FLAGS);

	Sg_desc	*sgp;
	Token	tok;


	/* Opening '{' token */
	if (gettoken_leftbkt(mf, MSG_ORIG(MSG_MAPKW_STACK)) == TK_ERROR)
		return (TK_ERROR);

	/* Fetch the PT_SUNWSTACK segment descriptor */
	sgp = ld_map_seg_stack(mf);

	/* Parse the attributes */
	if (parse_attributes(mf, MSG_ORIG(MSG_MAPKW_STACK),
	    attr_list, attr_list_bufsize, sgp) == TK_ERROR)
		return (TK_ERROR);

	/* Terminating ';' */
	tok = gettoken_semicolon(mf, MSG_ORIG(MSG_MAPKW_STACK));
	if (tok == TK_ERROR)
		return (TK_ERROR);

	if (DBG_ENABLED) {
		Xword ndx = ld_map_seg_index(mf, sgp);

		Dbg_map_seg(mf->mf_ofl, DBG_STATE_MOD_AFTER, ndx, sgp,
		    mf->mf_lineno);
	}

	return (tok);
}

/*
 * at_sym_aux(): Value for AUXILIARY= is not an object name
 */
static void
gts_efunc_at_sym_aux(Mapfile *mf, Token tok, ld_map_tkval_t *tkv)
{
	Conv_inv_buf_t	inv_buf;

	mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_OBJNAM),
	    MSG_ORIG(MSG_MAPKW_AUX), ld_map_tokenstr(tok, tkv, &inv_buf));
}

/*
 * SYMBOL [version_name] { symbol_name { AUXILIARY = soname
 * -------------------------------------------------^
 */
static Token
at_sym_aux(Mapfile *mf, Token eq_tok, void *uvalue)
{
	symbol_state_t	*ss = uvalue;
	ld_map_tkval_t	tkv;

	/* auxiliary filter soname */
	if (gettoken_str(mf, 0, &tkv, gts_efunc_at_sym_aux) == TK_ERROR)
		return (TK_ERROR);

	ld_map_sym_filtee(mf, &ss->ss_mv, &ss->ss_ms, FLG_SY_AUXFLTR,
	    tkv.tkv_str);

	/* terminator */
	return (gettoken_term(mf, MSG_ORIG(MSG_MAPKW_AUX)));
}

/*
 * at_sym_filter(): Value for FILTER= is not an object name
 */
static void
gts_efunc_at_sym_filter(Mapfile *mf, Token tok, ld_map_tkval_t *tkv)
{
	Conv_inv_buf_t	inv_buf;

	mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_OBJNAM),
	    MSG_ORIG(MSG_MAPKW_FILTER), ld_map_tokenstr(tok, tkv, &inv_buf));
}

/*
 * SYMBOL [version_name] { symbol_name { FILTER = soname
 * ----------------------------------------------^
 */
static Token
at_sym_filter(Mapfile *mf, Token eq_tok, void *uvalue)
{
	symbol_state_t	*ss = uvalue;
	ld_map_tkval_t	tkv;

	/* filter soname */
	if (gettoken_str(mf, 0, &tkv, gts_efunc_at_sym_filter) == TK_ERROR)
		return (TK_ERROR);

	ld_map_sym_filtee(mf, &ss->ss_mv, &ss->ss_ms, FLG_SY_STDFLTR,
	    tkv.tkv_str);

	/* terminator */
	return (gettoken_term(mf, MSG_ORIG(MSG_MAPKW_FILTER)));
}

/*
 * SYMBOL [version_name] { symbol_name { FLAGS = ...
 * ---------------------------------------------^
 */
static Token
at_sym_flags(Mapfile *mf, Token eq_tok, void *uvalue)
{
	typedef struct {
		const char	*name;
		sd_flag_t	value;
	} symflag_t;

	static symflag_t symflag_list[] = {
		{ MSG_ORIG(MSG_MAPKW_DIRECT),		FLG_SY_DIR },
		{ MSG_ORIG(MSG_MAPKW_DYNSORT),		FLG_SY_DYNSORT },
		{ MSG_ORIG(MSG_MAPKW_EXTERN),		FLG_SY_EXTERN },
		{ MSG_ORIG(MSG_MAPKW_INTERPOSE),	FLG_SY_INTPOSE },
		{ MSG_ORIG(MSG_MAPKW_NODIRECT),		FLG_SY_NDIR },
		{ MSG_ORIG(MSG_MAPKW_NODYNSORT),	FLG_SY_NODYNSORT },
		{ MSG_ORIG(MSG_MAPKW_PARENT),		FLG_SY_PARENT },

		/* List must be null terminated */
		{ 0 }
	};

	/*
	 * Size of buffer needed to format the names in flag_list[]. Must
	 * be kept in sync with flag_list.
	 */
	static size_t	symflag_list_bufsize =
	    KW_NAME_SIZE(MSG_MAPKW_DIRECT) +
	    KW_NAME_SIZE(MSG_MAPKW_DYNSORT) +
	    KW_NAME_SIZE(MSG_MAPKW_EXTERN) +
	    KW_NAME_SIZE(MSG_MAPKW_INTERPOSE) +
	    KW_NAME_SIZE(MSG_MAPKW_NODIRECT) +
	    KW_NAME_SIZE(MSG_MAPKW_NODYNSORT) +
	    KW_NAME_SIZE(MSG_MAPKW_PARENT);

	symbol_state_t	*ss = uvalue;
	int		done;
	symflag_t	*symflag;
	int		cnt = 0;
	Token		tok;
	ld_map_tkval_t	tkv;
	Conv_inv_buf_t	inv_buf;
	Ofl_desc	*ofl = mf->mf_ofl;

	for (done = 0; done == 0; ) {
		switch (tok = ld_map_gettoken(mf, TK_F_KEYWORD, &tkv)) {
		case TK_ERROR:
			return (TK_ERROR);

		case TK_STRING:
			symflag = ld_map_kwfind(tkv.tkv_str, symflag_list,
			    SGSOFFSETOF(symflag_t, name), sizeof (symflag[0]));
			if (symflag == NULL)
				goto bad_flag;
			cnt++;
			/*
			 * Apply the flag:
			 *
			 * Although tempting to make all of this table-driven
			 * via added fields in symflag_t, there's enough
			 * variation in what each flag does to make that
			 * not quite worthwhile.
			 *
			 * Similarly, it is tempting to use common code to
			 * to do this work from map_support.c. However, the
			 * v1 code mixes unrelated things (flags, symbol types,
			 * value, size, etc) in single cascading series of
			 * strcmps, whereas our parsing separates those things
			 * from each other. Merging the code would require doing
			 * two strcmps for each item, or other complexity,
			 * which I judge not to be worthwhile.
			 */
			switch (symflag->value) {
			case FLG_SY_DIR:
				ss->ss_ms.ms_sdflags |= FLG_SY_DIR;
				ofl->ofl_flags |= FLG_OF_SYMINFO;
				break;
			case FLG_SY_DYNSORT:
				ss->ss_ms.ms_sdflags |= FLG_SY_DYNSORT;
				ss->ss_ms.ms_sdflags &= ~FLG_SY_NODYNSORT;
				break;
			case FLG_SY_EXTERN:
				ss->ss_ms.ms_sdflags |= FLG_SY_EXTERN;
				ofl->ofl_flags |= FLG_OF_SYMINFO;
				break;
			case FLG_SY_INTPOSE:
				if (!(ofl->ofl_flags & FLG_OF_EXEC)) {
					mf_fatal0(mf,
					    MSG_INTL(MSG_MAP_NOINTPOSE));
					ss->ss_mv.mv_errcnt++;
					break;
				}
				ss->ss_ms.ms_sdflags |= FLG_SY_INTPOSE;
				ofl->ofl_flags |= FLG_OF_SYMINFO;
				ofl->ofl_dtflags_1 |= DF_1_SYMINTPOSE;
				break;
			case FLG_SY_NDIR:
				ss->ss_ms.ms_sdflags |= FLG_SY_NDIR;
				ofl->ofl_flags |= FLG_OF_SYMINFO;
				ofl->ofl_flags1 |=
				    (FLG_OF1_NDIRECT | FLG_OF1_NGLBDIR);
				break;
			case FLG_SY_NODYNSORT:
				ss->ss_ms.ms_sdflags &= ~FLG_SY_DYNSORT;
				ss->ss_ms.ms_sdflags |= FLG_SY_NODYNSORT;
				break;
			case FLG_SY_PARENT:
				ss->ss_ms.ms_sdflags |= FLG_SY_PARENT;
				ofl->ofl_flags |= FLG_OF_SYMINFO;
				break;
			}
			break;
		case TK_RIGHTBKT:
		case TK_SEMICOLON:
			done = 1;
			break;

		default:
		bad_flag:
			{
				char buf[VLA_SIZE(symflag_list_bufsize)];

				mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_SYMFLAG),
				    ld_map_kwnames(symflag_list,
				    SGSOFFSETOF(symflag_t, name),
				    sizeof (symflag[0]), buf,
				    symflag_list_bufsize),
				    ld_map_tokenstr(tok, &tkv, &inv_buf));
			}
			return (TK_ERROR);
		}
	}

	/* Make sure there was at least one flag specified */
	if (cnt == 0) {
		mf_fatal(mf, MSG_INTL(MSG_MAP_NOVALUES),
		    MSG_ORIG(MSG_MAPKW_FLAGS));
		return (TK_ERROR);
	}

	return (tok);		/* Either TK_SEMICOLON or TK_RIGHTBKT */
}

/*
 * SYMBOL [version_name] { symbol_name { SIZE = value
 * --------------------------------------------^
 */
static Token
at_sym_size(Mapfile *mf, Token eq_tok, void *uvalue)
{
	symbol_state_t	*ss = uvalue;
	ld_map_tkval_t	tkv;

	/* value */
	if (gettoken_int(mf, MSG_ORIG(MSG_MAPKW_SIZE), &tkv,
	    TK_F_MULOK) == TK_ERROR)
		return (TK_ERROR);

	ss->ss_ms.ms_size = tkv.tkv_int.tkvi_value;
	ss->ss_ms.ms_size_set = TRUE;

	/* terminator */
	return (gettoken_term(mf, MSG_ORIG(MSG_MAPKW_SIZE)));
}

typedef struct {
	const char	*name;		/* type name */
	Word		ms_shndx;	/* symbol section index */
	uchar_t		ms_type;	/* STT_ symbol type */
} at_sym_type_t;

static at_sym_type_t at_sym_type_list[] = {
	{ MSG_ORIG(MSG_MAPKW_COMMON),	SHN_COMMON,	STT_OBJECT },
	{ MSG_ORIG(MSG_MAPKW_DATA),	SHN_ABS,	STT_OBJECT },
	{ MSG_ORIG(MSG_MAPKW_FUNCTION),	SHN_ABS,	STT_FUNC },

	/* List must be null terminated */
	{ 0 }
};

/*
 * Size of buffer needed to format the names in at_sym_type_list[]. Must
 * be kept in sync with at_sym_type_list.
 */
static size_t	at_sym_type_list_bufsize =
    KW_NAME_SIZE(MSG_MAPKW_COMMON) +
    KW_NAME_SIZE(MSG_MAPKW_DATA) +
    KW_NAME_SIZE(MSG_MAPKW_FUNCTION);

/*
 * at_sym_type(): Value for TYPE= is not a symbol type
 */
static void
gts_efunc_at_sym_type(Mapfile *mf, Token tok, ld_map_tkval_t *tkv)
{
	Conv_inv_buf_t	inv_buf;
	char		buf[VLA_SIZE(at_sym_type_list_bufsize)];

	mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_SYMTYPE),
	    ld_map_kwnames(at_sym_type_list, SGSOFFSETOF(at_sym_type_t, name),
	    sizeof (at_sym_type_list[0]), buf, at_sym_type_list_bufsize),
	    ld_map_tokenstr(tok, tkv, &inv_buf));
}

/*
 * SYMBOL [version_name] { symbol_name { TYPE = symbol_type
 * --------------------------------------------^
 */
static Token
at_sym_type(Mapfile *mf, Token eq_tok, void *uvalue)
{
	symbol_state_t	*ss = uvalue;
	at_sym_type_t	*type;
	ld_map_tkval_t	tkv;

	/* type keyword */
	if (gettoken_str(mf, TK_F_KEYWORD, &tkv, gts_efunc_at_sym_type) ==
	    TK_ERROR)
		return (TK_ERROR);

	type = ld_map_kwfind(tkv.tkv_str, at_sym_type_list,
	    SGSOFFSETOF(at_sym_type_t, name), sizeof (type[0]));
	if (type == NULL) {
		gts_efunc_at_sym_type(mf, TK_STRING, &tkv);
		return (TK_ERROR);
	}

	ss->ss_ms.ms_shndx = type->ms_shndx;
	ss->ss_ms.ms_sdflags |= FLG_SY_SPECSEC;
	ss->ss_ms.ms_type = type->ms_type;

	/* terminator */
	return (gettoken_term(mf, MSG_ORIG(MSG_MAPKW_TYPE)));
}

/*
 * SYMBOL [version_name] { symbol_name { VALUE = value
 * ---------------------------------------------^
 */
static Token
at_sym_value(Mapfile *mf, Token eq_tok, void *uvalue)
{
	symbol_state_t	*ss = uvalue;
	ld_map_tkval_t	tkv;

	/* value */
	if (gettoken_int(mf, MSG_ORIG(MSG_MAPKW_VALUE), &tkv, 0) == TK_ERROR)
		return (TK_ERROR);

	ss->ss_ms.ms_value = tkv.tkv_int.tkvi_value;
	ss->ss_ms.ms_value_set = TRUE;

	/* terminator */
	return (gettoken_term(mf, MSG_ORIG(MSG_MAPKW_VALUE)));
}

typedef struct {
	const char	*name;
	uchar_t		ms_type;
} at_ass_type_t;

static at_ass_type_t	at_ass_type_list[] = {
	/* Accept DATA as well to match sym attrs */
	{ MSG_ORIG(MSG_MAPKW_DATA),	STT_OBJECT },
	{ MSG_ORIG(MSG_MAPKW_OBJECT),	STT_OBJECT },
	{ MSG_ORIG(MSG_MAPKW_FUNC),	STT_FUNC },
	/* Accept FUNCTION as well to match sym attrs */
	{ MSG_ORIG(MSG_MAPKW_FUNCTION),	STT_FUNC },
	{ MSG_ORIG(MSG_MAPKW_SECTION),	STT_SECTION },
	{ MSG_ORIG(MSG_MAPKW_FILE),	STT_FILE },
	{ MSG_ORIG(MSG_MAPKW_COMMON),	STT_COMMON },
	{ MSG_ORIG(MSG_MAPKW_TLS),	STT_TLS },
	{ 0 }
};

static size_t	at_ass_type_list_bufsize =
    KW_NAME_SIZE(MSG_MAPKW_OBJECT) +
    KW_NAME_SIZE(MSG_MAPKW_FUNC) +
    KW_NAME_SIZE(MSG_MAPKW_FUNCTION) +
    KW_NAME_SIZE(MSG_MAPKW_SECTION) +
    KW_NAME_SIZE(MSG_MAPKW_FILE) +
    KW_NAME_SIZE(MSG_MAPKW_COMMON) +
    KW_NAME_SIZE(MSG_MAPKW_TLS);

static void
gts_efunc_at_ass_type(Mapfile *mf, Token tok, ld_map_tkval_t *tkv)
{
	Conv_inv_buf_t	inv_buf;
	char		buf[VLA_SIZE(at_ass_type_list_bufsize)];

	mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_SYMTYPE),
	    ld_map_kwnames(at_ass_type_list, SGSOFFSETOF(at_ass_type_t, name),
	    sizeof (at_ass_type_list[0]), buf, at_ass_type_list_bufsize),
	    ld_map_tokenstr(tok, tkv, &inv_buf));
}

typedef struct {
	const char	*name;		/* attribute name */
	Boolean		ms_bits;	/* bits? */
} at_ass_shattr_t;

static at_ass_shattr_t	at_ass_shattr_list[] = {
	{ MSG_ORIG(MSG_MAPKW_BITS),	TRUE },
	{ MSG_ORIG(MSG_MAPKW_NOBITS),	FALSE },
	{ 0 }
};

static size_t	at_ass_shattr_list_bufsize =
    KW_NAME_SIZE(MSG_MAPKW_BITS) +
    KW_NAME_SIZE(MSG_MAPKW_NOBITS);

static void
gts_efunc_at_ass_shattr(Mapfile *mf, Token tok, ld_map_tkval_t *tkv)
{
	Conv_inv_buf_t	inv_buf;
	char		buf[VLA_SIZE(at_ass_shattr_list_bufsize)];

	mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_SHATTRTYPE),
	    ld_map_kwnames(at_ass_shattr_list,
	    SGSOFFSETOF(at_ass_shattr_t, name), sizeof (at_ass_shattr_list[0]),
	    buf, at_ass_shattr_list_bufsize),
	    ld_map_tokenstr(tok, tkv, &inv_buf));
}

static Token
at_ass_shattr(Mapfile *mf, Token eq_tok, void *uvalue)
{
	symbol_state_t	*ss = uvalue;
	at_ass_shattr_t	*shattr;
	ld_map_tkval_t	tkv;

	if (gettoken_str(mf, TK_F_KEYWORD, &tkv,
	    gts_efunc_at_ass_shattr) == TK_ERROR)
		return (TK_ERROR);

	shattr = ld_map_kwfind(tkv.tkv_str, at_ass_shattr_list,
	    SGSOFFSETOF(at_ass_shattr_t, name), sizeof (shattr[0]));

	if (shattr == NULL) {
		gts_efunc_at_ass_shattr(mf, TK_STRING, &tkv);
		return (TK_ERROR);
	}

	ss->ss_ma.ass_bits = shattr->ms_bits;
	ss->ss_ma.ass_enabled |= SYM_ASSERT_BITS;

	return (gettoken_term(mf, MSG_ORIG(MSG_MAPKW_SHATTR)));
}

typedef struct {
	const char	*name;		/* binding name */
	uchar_t		ms_bind;	/* STB_ value */
} at_ass_bind_t;

static at_ass_bind_t	at_ass_bind_list[] = {
	{ MSG_ORIG(MSG_MAPKW_GLOBAL),	STB_GLOBAL },
	{ MSG_ORIG(MSG_MAPKW_LOCAL),	STB_LOCAL },
	{ MSG_ORIG(MSG_MAPKW_WEAK),	STB_WEAK },
	{ 0 }
};

static size_t	at_ass_bind_list_bufsize =
    KW_NAME_SIZE(MSG_MAPKW_GLOBAL) +
    KW_NAME_SIZE(MSG_MAPKW_LOCAL) +
    KW_NAME_SIZE(MSG_MAPKW_WEAK);

static void
gts_efunc_at_ass_bind(Mapfile *mf, Token tok, ld_map_tkval_t *tkv)
{
	Conv_inv_buf_t	inv_buf;
	char		buf[VLA_SIZE(at_ass_bind_list_bufsize)];

	mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_BINDTYPE),
	    ld_map_kwnames(at_ass_bind_list, SGSOFFSETOF(at_ass_bind_t, name),
	    sizeof (at_ass_bind_list[0]), buf, at_ass_bind_list_bufsize),
	    ld_map_tokenstr(tok, tkv, &inv_buf));
}

static Token
at_ass_bind(Mapfile *mf, Token eq_tok, void *uvalue)
{
	symbol_state_t	*ss = uvalue;
	at_ass_bind_t	*bind;
	ld_map_tkval_t	tkv;

	if (gettoken_str(mf, TK_F_KEYWORD, &tkv,
	    gts_efunc_at_ass_bind) == TK_ERROR)
		return (TK_ERROR);

	bind = ld_map_kwfind(tkv.tkv_str, at_ass_bind_list,
	    SGSOFFSETOF(at_ass_bind_t, name), sizeof (bind[0]));

	if (bind == NULL) {
		gts_efunc_at_ass_bind(mf, TK_STRING, &tkv);
		return (TK_ERROR);
	}

	ss->ss_ma.ass_bind = bind->ms_bind;
	ss->ss_ma.ass_enabled |= SYM_ASSERT_BIND;

	return (gettoken_term(mf, MSG_ORIG(MSG_MAPKW_BIND)));
}

static Token
at_ass_size(Mapfile *mf, Token eq_tok, void *uvalue)
{
	symbol_state_t	*ss = uvalue;
	ld_map_tkval_t	tkv;

	if (gettoken_int(mf, MSG_ORIG(MSG_MAPKW_SIZE), &tkv,
	    TK_F_MULOK) == TK_ERROR)
		return (TK_ERROR);

	ss->ss_ma.ass_size = tkv.tkv_int.tkvi_value;
	ss->ss_ma.ass_enabled |= SYM_ASSERT_SIZE;

	return (gettoken_term(mf, MSG_ORIG(MSG_MAPKW_SIZE)));
}

static Token
at_ass_alias(Mapfile *mf, Token eq_tok, void *uvalue)
{
	symbol_state_t	*ss = uvalue;
	ld_map_tkval_t	tkv;

	if (ld_map_gettoken(mf, 0, &tkv) != TK_STRING) {
		mf_fatal0(mf, MSG_INTL(MSG_MAP_BADALIAS));
		return (TK_ERROR);
	}

	ss->ss_ma.ass_alias = tkv.tkv_str;
	ss->ss_ma.ass_enabled |= SYM_ASSERT_ALIAS;

	return (gettoken_term(mf, MSG_ORIG(MSG_MAPKW_ALIAS)));
}

static Token
at_ass_type(Mapfile *mf, Token eq_tok, void *uvalue)
{
	ld_map_tkval_t	 tkv;
	at_ass_type_t	*type;
	symbol_state_t	*ss = uvalue;

	if (gettoken_str(mf, TK_F_KEYWORD, &tkv,
	    gts_efunc_at_ass_type) == TK_ERROR)
		return (TK_ERROR);

	type = ld_map_kwfind(tkv.tkv_str, at_ass_type_list,
	    SGSOFFSETOF(at_sym_type_t, name), sizeof (type[0]));

	if (type == NULL) {
		gts_efunc_at_ass_type(mf, TK_STRING, &tkv);
		return (TK_ERROR);
	}

	ss->ss_ma.ass_type = type->ms_type;
	ss->ss_ma.ass_enabled |= SYM_ASSERT_TYPE;

	return (gettoken_term(mf, MSG_ORIG(MSG_MAPKW_ASSERT)));
}

static Token
at_sym_assert(Mapfile *mf, Token eq_tok, void *uvalue)
{
	static attr_t	attr_list[] = {
		{ MSG_ORIG(MSG_MAPKW_ALIAS),	at_ass_alias,	ATTR_FMT_EQ },
		/*
		 * The Solaris manuals describe both BIND and BINDING, take both
		 * but prefer BINDING
		 */
		{ MSG_ORIG(MSG_MAPKW_BIND),	at_ass_bind,	ATTR_FMT_EQ },
		{ MSG_ORIG(MSG_MAPKW_BINDING),	at_ass_bind,	ATTR_FMT_EQ },
		{ MSG_ORIG(MSG_MAPKW_SHATTR),	at_ass_shattr,	ATTR_FMT_EQ },
		{ MSG_ORIG(MSG_MAPKW_SIZE),	at_ass_size,	ATTR_FMT_EQ },
		{ MSG_ORIG(MSG_MAPKW_TYPE),	at_ass_type,	ATTR_FMT_EQ },
		{ 0 }
	};

	static size_t	attr_list_bufsize =
	    KW_NAME_SIZE(MSG_MAPKW_ALIAS) +
	    KW_NAME_SIZE(MSG_MAPKW_BIND) +
	    KW_NAME_SIZE(MSG_MAPKW_BINDING) +
	    KW_NAME_SIZE(MSG_MAPKW_SHATTR) +
	    KW_NAME_SIZE(MSG_MAPKW_SIZE) +
	    KW_NAME_SIZE(MSG_MAPKW_TYPE);

	symbol_state_t *ss = uvalue;
	int done = 0;
	Token tok;
	ld_map_tkval_t tkv;
	Conv_inv_buf_t	inv_buf;

	/* Read assertions until the closing } */
	for (done = 0; done == 0; ) {
		switch (tok = ld_map_gettoken(mf, 0, &tkv)) {
		case TK_ERROR:
			return (TK_ERROR);
		case TK_LEFTBKT:
			if (parse_attributes(mf, ss->ss_ms.ms_name,
			    attr_list, attr_list_bufsize, ss) == TK_ERROR)
				return (TK_ERROR);

			/*
			 * If we're stating we're an alias for another symbol,
			 * the only other thing that maybe specified for
			 * _this_ symbol is its binding.
			 */
			if ((ss->ss_ma.ass_enabled & SYM_ASSERT_ALIAS) &&
			    (ss->ss_ma.ass_enabled &
			    ~(SYM_ASSERT_ALIAS|SYM_ASSERT_BIND))) {
				mf_fatal(mf, MSG_INTL(MSG_MAP_ALIAS_COMBO),
				    ss->ss_ms.ms_name);
				return (TK_ERROR);
			}

			tok = gettoken_term(mf, MSG_INTL(MSG_MAP_SYMATTR));
			if (tok == TK_ERROR)
				return (TK_ERROR);
			if (tok == TK_SEMICOLON)
				return (tok);
			break;
		default:
			mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_SYMDELIM),
			    ld_map_tokenstr(tok, &tkv, &inv_buf));
			return (TK_ERROR);
		}
	}

	/* If we drop through here, something is wrong */
	return (TK_ERROR);
}

/*
 * Parse the attributes for a SCOPE or VERSION symbol directive.
 *
 * entry:
 *	mf - Mapfile descriptor
 *	dir_name - Name of directive.
 *	ss - Pointer to symbol state block that has had its ss_mv
 *		member initialzed via a call to ld_map_sym_ver_init().
 *
 * exit:
 *	parse_symbol_attributes() returns TK_RIGHTBKT on success, and TK_ERROR
 *	on failure.
 */
static Token
parse_symbol_attributes(Mapfile *mf, const char *dir_name, symbol_state_t *ss)
{
	/* Symbol attributes */
	static attr_t attr_list[] = {
		{ MSG_ORIG(MSG_MAPKW_AUX),	at_sym_aux,	ATTR_FMT_EQ },
		{ MSG_ORIG(MSG_MAPKW_FILTER),	at_sym_filter,	ATTR_FMT_EQ },
		{ MSG_ORIG(MSG_MAPKW_FLAGS),	at_sym_flags,	ATTR_FMT_EQ },
		{ MSG_ORIG(MSG_MAPKW_SIZE),	at_sym_size,	ATTR_FMT_EQ },
		{ MSG_ORIG(MSG_MAPKW_TYPE),	at_sym_type,	ATTR_FMT_EQ },
		{ MSG_ORIG(MSG_MAPKW_VALUE),	at_sym_value,	ATTR_FMT_EQ },
		{ MSG_ORIG(MSG_MAPKW_ASSERT),	at_sym_assert,	ATTR_FMT_EQ },

		/* List must be null terminated */
		{ 0 }
	};

	/*
	 * Size of buffer needed to format the names in attr_list[]. Must
	 * be kept in sync with attr_list.
	 */
	static size_t	attr_list_bufsize =
	    KW_NAME_SIZE(MSG_MAPKW_AUX) +
	    KW_NAME_SIZE(MSG_MAPKW_FILTER) +
	    KW_NAME_SIZE(MSG_MAPKW_FLAGS) +
	    KW_NAME_SIZE(MSG_MAPKW_SIZE) +
	    KW_NAME_SIZE(MSG_MAPKW_TYPE) +
	    KW_NAME_SIZE(MSG_MAPKW_VALUE) +
	    KW_NAME_SIZE(MSG_MAPKW_ASSERT);

	Token		tok;
	ld_map_tkval_t	tkv, tkv_sym;
	int		done;
	Conv_inv_buf_t	inv_buf;

	/* Read attributes until the closing '}' is seen */
	for (done = 0; done == 0; ) {
		/*
		 * We have to allow quotes around symbol names, but the
		 * name we read may also be a symbol scope keyword. We won't
		 * know which until we read the following token, and so have
		 * to allow quotes for both. Hence, symbol scope names can
		 * be quoted --- an unlikely occurrence and not worth
		 * complicating the code.
		 */
		switch (tok = ld_map_gettoken(mf, 0, &tkv_sym)) {
		case TK_ERROR:
			return (TK_ERROR);

		case TK_STRING:
			/* Default value for all symbol attributes is 0 */
			(void) memset(&ss->ss_ms, 0, sizeof (ss->ss_ms));
			(void) memset(&ss->ss_ma, 0, sizeof (ss->ss_ma));
			ss->ss_ms.ms_name = tkv_sym.tkv_str;
			ss->ss_ma.ass_file = mf->mf_name;
			ss->ss_ma.ass_lineno = mf->mf_lineno;

			/*
			 * Turn off the WEAK flag to indicate that definitions
			 * are associated with this version. It would probably
			 * be more accurate to only remove this flag with the
			 * specification of global symbols, however setting it
			 * here allows enough slop to compensate for the
			 * various user inputs we've seen so far. Only if a
			 * closed version is specified (i.e., "SUNW_1.x {};")
			 * will a user get a weak version (which is how we
			 * document the creation of weak versions).
			 */
			ss->ss_mv.mv_vdp->vd_flags &= ~VER_FLG_WEAK;

			/*
			 * The meaning of this name depends on the following
			 * character:
			 *
			 *	:	Scope
			 *	;	Symbol without attributes
			 *	{	Symbol with attributes
			 */
			switch (tok = ld_map_gettoken(mf, 0, &tkv)) {
			case TK_ERROR:
				return (TK_ERROR);

			case TK_COLON:
				ld_map_sym_scope(mf, tkv_sym.tkv_str,
				    &ss->ss_mv);
				break;
			case TK_LEFTBKT:
				/* name is a symbol with attributes */
				if (parse_attributes(mf, tkv_sym.tkv_str,
				    attr_list, attr_list_bufsize, ss) ==
				    TK_ERROR)
					return (TK_ERROR);
				/* Terminating ';', or '}' */
				tok = gettoken_term(mf,
				    MSG_INTL(MSG_MAP_SYMATTR));
				if (tok == TK_ERROR)
					return (TK_ERROR);
				if (tok == TK_RIGHTBKT)
					done = 1;

				/* FALLTHROUGH */
			case TK_SEMICOLON: {
				ld_map_sym_t *ms = &ss->ss_ms;
				/*
				 * If an EXTERN or PARENT symbol has
				 * assertions issue an error, since we can't
				 * check them.
				 */
				if ((ss->ss_ma.ass_enabled != 0) &&
				    (((ms->ms_sdflags & FLG_SY_PARENT) != 0) ||
				    ((ms->ms_sdflags & FLG_SY_EXTERN) != 0))) {
					mf_fatal(mf,
					    MSG_INTL(MSG_MAP_EXTPAR_ASSERT),
					    ms->ms_name);
					return (TK_ERROR);
				}

				/*
				 * Add the new symbol. It should be noted that
				 * all symbols added by the mapfile start out
				 * with global scope, thus they will fall
				 * through the normal symbol resolution
				 * process.  Symbols defined as locals will
				 * be reduced in scope after all input file
				 * processing.
				 */
				if (!ld_map_sym_enter(mf, &ss->ss_mv,
				    &ss->ss_ms, &ss->ss_ma))
					return (TK_ERROR);
				break;
			}
			default:
				mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_SYMDELIM),
				    ld_map_tokenstr(tok, &tkv, &inv_buf));
				return (TK_ERROR);
			}
			break;

		case TK_RIGHTBKT:
			done = 1;
			break;

		case TK_SEMICOLON:
			break;		/* Ignore empty statement */

		case TK_STAR:
			/*
			 * Turn off the WEAK flag, as explained above for
			 * TK_STRING.
			 */
			ss->ss_mv.mv_vdp->vd_flags &= ~VER_FLG_WEAK;

			ld_map_sym_autoreduce(mf, &ss->ss_mv);

			/*
			 * Following token must be ';' to terminate the stmt,
			 * or '}' to terminate the whole directive.
			 */
			switch (tok = gettoken_term(mf, dir_name)) {
			case TK_ERROR:
				return (TK_ERROR);
			case TK_RIGHTBKT:
				done = 1;
				break;
			}
			break;

		default:
			mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_SYM),
			    ld_map_tokenstr(tok, &tkv_sym, &inv_buf));
			return (TK_ERROR);
		}
	}

	/*
	 * In the SYMBOL directive, we keep parsing in the face of
	 * errors that don't involve resources, to maximize what we
	 * can report in a single invocation. If we encountered such
	 * an error, act on the error(s) now.
	 */
	if (ss->ss_mv.mv_errcnt)
		return (TK_ERROR);

	return (tok);
}


/*
 * Top Level Directive:
 *
 * SYMBOL_SCOPE { ...
 * ------------^
 */
static Token
dir_symbol_scope(Mapfile *mf)
{
	symbol_state_t	ss;

	/* The first token must be a '{' */
	if (gettoken_leftbkt(mf, MSG_ORIG(MSG_MAPKW_SYMBOL_SCOPE)) == TK_ERROR)
		return (TK_ERROR);

	/* Establish the version descriptor and related data */
	if (!ld_map_sym_ver_init(mf, NULL, &ss.ss_mv))
		return (TK_ERROR);

	/* Read attributes until the closing '}' is seen */
	if (parse_symbol_attributes(mf, MSG_ORIG(MSG_MAPKW_SYMBOL_SCOPE),
	    &ss) == TK_ERROR)
		return (TK_ERROR);

	/* Terminating ';' */
	return (gettoken_semicolon(mf, MSG_ORIG(MSG_MAPKW_SYMBOL_SCOPE)));
}


/*
 * at_dv_allow(): Value for ALLOW= is not a version string
 */
static void
gts_efunc_dir_symbol_version(Mapfile *mf, Token tok, ld_map_tkval_t *tkv)
{
	Conv_inv_buf_t	inv_buf;

	mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_VERSION),
	    MSG_ORIG(MSG_MAPKW_SYMBOL_VERSION),
	    ld_map_tokenstr(tok, tkv, &inv_buf));
}

/*
 * Top Level Directive:
 *
 * SYMBOL_VERSION version_name { ...
 * --------------^
 */
static Token
dir_symbol_version(Mapfile *mf)
{

	ld_map_tkval_t	tkv;
	symbol_state_t	ss;

	/* The first token must be a version name */
	if (gettoken_str(mf, 0, &tkv, gts_efunc_dir_symbol_version) == TK_ERROR)
		return (TK_ERROR);

	/* The next token is expected to be '{' */
	if (gettoken_leftbkt(mf, MSG_ORIG(MSG_MAPKW_SYMBOL_VERSION)) ==
	    TK_ERROR)
		return (TK_ERROR);

	/* Establish the version descriptor and related data */
	if (!ld_map_sym_ver_init(mf, tkv.tkv_str, &ss.ss_mv))
		return (TK_ERROR);

	/* Read attributes until the closing '}' is seen */
	if (parse_symbol_attributes(mf, MSG_ORIG(MSG_MAPKW_SYMBOL_VERSION),
	    &ss) == TK_ERROR)
		return (TK_ERROR);

	/*
	 * Determine if any version references are provided after the close
	 * bracket, parsing up to the terminating ';'.
	 */
	if (!ld_map_sym_ver_fini(mf, &ss.ss_mv))
		return (TK_ERROR);

	return (TK_SEMICOLON);
}


/*
 * Parse the mapfile --- Solaris syntax
 */
Boolean
ld_map_parse_v2(Mapfile *mf)
{
	/* Valid top level mapfile directives */
	typedef struct {
		const char	*name;	/* Directive */
		dir_func_t	func;	/* Function to parse directive */
	} tldir_t;


	tldir_t dirlist[] = {
		{ MSG_ORIG(MSG_MAPKW_CAPABILITY),	dir_capability },
		{ MSG_ORIG(MSG_MAPKW_DEPEND_VERSIONS),	dir_depend_versions },
		{ MSG_ORIG(MSG_MAPKW_HDR_NOALLOC),	dir_hdr_noalloc },
		{ MSG_ORIG(MSG_MAPKW_LOAD_SEGMENT),	dir_load_segment },
		{ MSG_ORIG(MSG_MAPKW_NOTE_SEGMENT),	dir_note_segment },
		{ MSG_ORIG(MSG_MAPKW_NULL_SEGMENT),	dir_null_segment },
		{ MSG_ORIG(MSG_MAPKW_PHDR_ADD_NULL),	dir_phdr_add_null },
		{ MSG_ORIG(MSG_MAPKW_SEGMENT_ORDER),	dir_segment_order },
		{ MSG_ORIG(MSG_MAPKW_STACK),		dir_stack },
		{ MSG_ORIG(MSG_MAPKW_SYMBOL_SCOPE),	dir_symbol_scope },
		{ MSG_ORIG(MSG_MAPKW_SYMBOL_VERSION),	dir_symbol_version },

		/* List must be null terminated */
		{ 0 }
	};

	/*
	 * Size of buffer needed to format the names in dirlist[]. Must
	 * be kept in sync with dirlist.
	 */
	static size_t dirlist_bufsize =
	    KW_NAME_SIZE(MSG_MAPKW_CAPABILITY) +
	    KW_NAME_SIZE(MSG_MAPKW_DEPEND_VERSIONS) +
	    KW_NAME_SIZE(MSG_MAPKW_HDR_NOALLOC) +
	    KW_NAME_SIZE(MSG_MAPKW_LOAD_SEGMENT) +
	    KW_NAME_SIZE(MSG_MAPKW_NOTE_SEGMENT) +
	    KW_NAME_SIZE(MSG_MAPKW_NULL_SEGMENT) +
	    KW_NAME_SIZE(MSG_MAPKW_PHDR_ADD_NULL) +
	    KW_NAME_SIZE(MSG_MAPKW_SEGMENT_ORDER) +
	    KW_NAME_SIZE(MSG_MAPKW_STACK) +
	    KW_NAME_SIZE(MSG_MAPKW_SYMBOL_SCOPE) +
	    KW_NAME_SIZE(MSG_MAPKW_SYMBOL_VERSION);

	Token		tok;		/* current token. */
	ld_map_tkval_t	tkv;		/* Value of token */
	tldir_t		*tldir;
	Conv_inv_buf_t	inv_buf;

	for (;;) {
		tok = ld_map_gettoken(mf, TK_F_EOFOK | TK_F_KEYWORD, &tkv);
		switch (tok) {
		case TK_ERROR:
			return (FALSE);
		case TK_EOF:
			return (TRUE);
		case TK_SEMICOLON: /* Terminator, or empty directive: Ignore */
			break;
		case TK_STRING:
			/* Map name to entry in dirlist[] */
			tldir = ld_map_kwfind(tkv.tkv_str, dirlist,
			    SGSOFFSETOF(tldir_t, name), sizeof (dirlist[0]));

			/* Not a directive we know? */
			if (tldir == NULL)
				goto bad_dirtok;

			/* Call the function associated with this directive */
			if (tldir->func(mf) == TK_ERROR)
				return (FALSE);
			break;
		default:
		bad_dirtok:
			{
				char buf[VLA_SIZE(dirlist_bufsize)];

				mf_fatal(mf, MSG_INTL(MSG_MAP_EXP_DIR),
				    ld_map_kwnames(dirlist,
				    SGSOFFSETOF(tldir_t, name),
				    sizeof (dirlist[0]), buf, dirlist_bufsize),
				    ld_map_tokenstr(tok, &tkv, &inv_buf));
			}
			return (FALSE);
		}
	}
}