read.c

早期freebsd实现

static void
s_align()
{
    register unsigned int temp;
    register long int temp_fill;
    unsigned int i;

    temp = get_absolute_expression ();
#define MAX_ALIGNMENT (1 << 15)
    if ( temp > MAX_ALIGNMENT ) {
	as_bad("Alignment too large: %d. assumed.", temp = MAX_ALIGNMENT);
    }

    /*
     * For the sparc, `.align (1<<n)' actually means `.align n'
     * so we have to convert it.
     */
    if (temp != 0) {
	for (i = 0; (temp & 1) == 0; temp >>= 1, ++i)
	    ;
    }
    if (temp != 1)
	as_bad("Alignment not a power of 2");

    temp = i;
    if (*input_line_pointer == ',') {
	input_line_pointer ++;
	temp_fill = get_absolute_expression ();
    } else {
	temp_fill = 0;
    }
    /* Only make a frag if we HAVE to. . . */
    if (temp && ! need_pass_2)
	frag_align (temp, (int)temp_fill);

    demand_empty_rest_of_line();
}
#else

void
s_align()
{
	register int temp;
	register long int temp_fill;

	temp = get_absolute_expression ();
#define MAX_ALIGNMENT (15)
	if ( temp > MAX_ALIGNMENT )
		as_bad("Alignment too large: %d. assumed.", temp = MAX_ALIGNMENT);
	else if ( temp < 0 ) {
		as_bad("Alignment negative. 0 assumed.");
		temp = 0;
	}
	if ( *input_line_pointer == ',' ) {
		input_line_pointer ++;
		temp_fill = get_absolute_expression ();
	} else
		temp_fill = 0;
	/* Only make a frag if we HAVE to. . . */
	if ( temp && ! need_pass_2 )
		frag_align (temp, (int)temp_fill);
	demand_empty_rest_of_line();
}
#endif

void
s_comm()
{
	register char *name;
	register char c;
	register char *p;
	register int temp;
	register symbolS *	symbolP;

	name = input_line_pointer;
	c = get_symbol_end();
	/* just after name is now '\0' */
	p = input_line_pointer;
	*p = c;
	SKIP_WHITESPACE();
	if ( * input_line_pointer != ',' ) {
		as_bad("Expected comma after symbol-name");
		ignore_rest_of_line();
		return;
	}
	input_line_pointer ++; /* skip ',' */
	if ( (temp = get_absolute_expression ()) < 0 ) {
		as_warn(".COMMon length (%d.) <0! Ignored.", temp);
		ignore_rest_of_line();
		return;
	}
	*p = 0;
	symbolP = symbol_find_or_make (name);
	*p = c;
	if (   (symbolP -> sy_type & N_TYPE) != N_UNDF ||
 symbolP -> sy_other != 0 || symbolP -> sy_desc != 0) {
		as_warn( "Ignoring attempt to re-define symbol");
		ignore_rest_of_line();
		return;
	}
	if (symbolP -> sy_value) {
		if (symbolP -> sy_value != temp)
			as_warn( "Length of .comm \"%s\" is already %d. Not changed to %d.",
 symbolP -> sy_name, symbolP -> sy_value, temp);
	} else {
		symbolP -> sy_value = temp;
		symbolP -> sy_type |= N_EXT;
	}
#ifdef VMS
	if(!temp)
		symbolP->sy_other = const_flag;
#endif
	know( symbolP -> sy_frag == &zero_address_frag );
	demand_empty_rest_of_line();
}

#ifdef VMS
void
s_const()
{
	register int temp;

	temp = get_absolute_expression ();
	subseg_new (SEG_DATA, (subsegT)temp);
	const_flag = 1;
	demand_empty_rest_of_line();
}
#endif

void
s_data()
{
	register int temp;

	temp = get_absolute_expression ();
	subseg_new (SEG_DATA, (subsegT)temp);
#ifdef VMS
	const_flag = 0;
#endif
	demand_empty_rest_of_line();
}

void
s_desc()
{
	register char *name;
	register char c;
	register char *p;
	register symbolS *	symbolP;
	register int temp;

	/*
	 * Frob invented at RMS' request. Set the n_desc of a symbol.
	 */
	name = input_line_pointer;
	c = get_symbol_end();
	p = input_line_pointer;
	symbolP = symbol_table_lookup (name);
	* p = c;
	SKIP_WHITESPACE();
	if ( * input_line_pointer != ',' ) {
		*p = 0;
		as_bad("Expected comma after name \"%s\"", name);
		*p = c;
		ignore_rest_of_line();
	} else {
		input_line_pointer ++;
		temp = get_absolute_expression ();
		*p = 0;
		symbolP = symbol_find_or_make (name);
		*p = c;
		symbolP -> sy_desc = temp;
	}
	demand_empty_rest_of_line();
}

void
s_file()
{
	register char *s;
	int	length;

	/* Some assemblers tolerate immediately following '"' */
	if ( s = demand_copy_string( & length ) ) {
		new_logical_line (s, -1);
		demand_empty_rest_of_line();
	}
}

void
s_fill()
{
	long int temp_repeat;
	long int temp_size;
	register long int temp_fill;
	char	*p;

	if ( get_absolute_expression_and_terminator(& temp_repeat) != ',' ) {
		input_line_pointer --; /* Backup over what was not a ','. */
		as_warn("Expect comma after rep-size in .fill");
		ignore_rest_of_line();
		return;
	}
	if ( get_absolute_expression_and_terminator( & temp_size) != ',' ) {
		  input_line_pointer --; /* Backup over what was not a ','. */
		  as_warn("Expected comma after size in .fill");
		  ignore_rest_of_line();
		  return;
	}
	/*
	 * This is to be compatible with BSD 4.2 AS, not for any rational reason.
	 */
#define BSD_FILL_SIZE_CROCK_8 (8)
	if ( temp_size > BSD_FILL_SIZE_CROCK_8 ) {
		as_bad(".fill size clamped to %d.", BSD_FILL_SIZE_CROCK_8);
		temp_size = BSD_FILL_SIZE_CROCK_8 ;
	} if ( temp_size < 0 ) {
		as_warn("Size negative: .fill ignored.");
		temp_size = 0;
	} else if ( temp_repeat <= 0 ) {
		as_warn("Repeat < 0, .fill ignored");
		temp_size = 0;
	}
	temp_fill = get_absolute_expression ();
	if ( temp_size && !need_pass_2 ) {
		p = frag_var (rs_fill, (int)temp_size, (int)temp_size, (relax_substateT)0, (symbolS *)0, temp_repeat, (char *)0);
		bzero (p, (int)temp_size);
/*
 * The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX flavoured AS.
 * The following bizzare behaviour is to be compatible with above.
 * I guess they tried to take up to 8 bytes from a 4-byte expression
 * and they forgot to sign extend. Un*x Sux.
 */
#define BSD_FILL_SIZE_CROCK_4 (4)
		md_number_to_chars (p, temp_fill, temp_size > BSD_FILL_SIZE_CROCK_4 ? BSD_FILL_SIZE_CROCK_4 : (int)temp_size);
/*
 * Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
 * but emits no error message because it seems a legal thing to do.
 * It is a degenerate case of .fill but could be emitted by a compiler.
 */
	}
	demand_empty_rest_of_line();
}

#ifdef DONTDEF
void
s_gdbbeg()
{
	register int temp;

	temp = get_absolute_expression ();
	if (temp < 0)
		as_warn( "Block number <0. Ignored." );
	else if (flagseen ['G'])
		gdb_block_beg ( (long int) temp, frag_now, (long int)(obstack_next_free(& frags) - frag_now -> fr_literal));
	demand_empty_rest_of_line ();
}

void
s_gdbblock()
{
	register int	position;
	int	temp;

	if (get_absolute_expression_and_terminator (&temp) != ',') {
		as_warn( "expected comma before position in .gdbblock");
		--input_line_pointer;
		ignore_rest_of_line ();
		return;
	}
	position = get_absolute_expression ();
	if (flagseen ['G'])
		gdb_block_position ((long int) temp, (long int) position);
	demand_empty_rest_of_line ();
}

void
s_gdbend()
{
	register int temp;

	temp = get_absolute_expression ();
	if (temp < 0)
		as_warn( "Block number <0. Ignored." );
	else if (flagseen ['G'])
		gdb_block_end ( (long int) temp, frag_now, (long int)(obstack_next_free(& frags) - frag_now -> fr_literal));
	demand_empty_rest_of_line ();
}

void
s_gdbsym()
{
	register char *name,
			*p;
	register char c;
	register symbolS *	symbolP;
	register int temp;

	name = input_line_pointer;
	c = get_symbol_end();
	p = input_line_pointer;
	symbolP = symbol_find_or_make (name);
	*p = c;
	SKIP_WHITESPACE();
	if ( * input_line_pointer != ',' ) {
		as_warn("Expected comma after name");
		ignore_rest_of_line();
		return;
	}
	input_line_pointer ++;
	if ( (temp = get_absolute_expression ()) < 0 ) {
		as_warn("Bad GDB symbol file offset (%d.) <0! Ignored.", temp);
		ignore_rest_of_line();
		return;
	}
	if (flagseen ['G'])
		gdb_symbols_fixup (symbolP, (long int)temp);
	demand_empty_rest_of_line ();
}

void
s_gdbline()
{
	int	file_number,
		lineno;

	if(get_absolute_expression_and_terminator(&file_number) != ',') {
		as_warn("expected comman after filenum in .gdbline");
		ignore_rest_of_line();
		return;
	}
	lineno=get_absolute_expression();
	if(flagseen['G'])
		gdb_line(file_number,lineno);
	demand_empty_rest_of_line();
}


void
s_gdblinetab()
{
	int	file_number,
		offset;

	if(get_absolute_expression_and_terminator(&file_number) != ',') {
		as_warn("expected comman after filenum in .gdblinetab");
		ignore_rest_of_line();
		return;
	}
	offset=get_absolute_expression();
	if(flagseen['G'])
		gdb_line_tab(file_number,offset);
	demand_empty_rest_of_line();
}
#endif	

void
s_globl()
{
	register char *name;
	register int c;
	register symbolS *	symbolP;

	do {
		name = input_line_pointer;
		c = get_symbol_end();
		symbolP = symbol_find_or_make (name);
		* input_line_pointer = c;
		SKIP_WHITESPACE();
		symbolP -> sy_type |= N_EXT;
		if(c==',') {
			input_line_pointer++;
			SKIP_WHITESPACE();
			if(*input_line_pointer=='\n')
				c='\n';
		}
	} while(c==',');
	demand_empty_rest_of_line();
}

void
s_lcomm()
{
	register char *name;
	register char c;
	register char *p;
	register int temp;
	register symbolS *	symbolP;

	name = input_line_pointer;
	c = get_symbol_end();
	p = input_line_pointer;
	*p = c;
	SKIP_WHITESPACE();
	if ( * input_line_pointer != ',' ) {
		as_warn("Expected comma after name");
		ignore_rest_of_line();
		return;
	}
	input_line_pointer ++;
	if ( (temp = get_absolute_expression ()) < 0 ) {
		as_warn("BSS length (%d.) <0! Ignored.", temp);
		ignore_rest_of_line();
		return;
	}
	*p = 0;
	symbolP = symbol_find_or_make (name);
	*p = c;
	if (   symbolP -> sy_other == 0
	    && symbolP -> sy_desc  == 0
	    && (   (   symbolP -> sy_type  == N_BSS
	    && symbolP -> sy_value == local_bss_counter)
	    || (   (symbolP -> sy_type & N_TYPE) == N_UNDF
	    && symbolP -> sy_value == 0))) {
		symbolP -> sy_value = local_bss_counter;
		symbolP -> sy_type  = N_BSS;
		symbolP -> sy_frag  = & bss_address_frag;
		local_bss_counter += temp;
	} else
		as_warn( "Ignoring attempt to re-define symbol from %d. to %d.",
 symbolP -> sy_value, local_bss_counter );
	demand_empty_rest_of_line();
}

void
s_line()
{
	/* Assume delimiter is part of expression. */
	/* BSD4.2 as fails with delightful bug, so we */
	/* are not being incompatible here. */
	new_logical_line ((char *)NULL, (int)(get_absolute_expression ()));
	demand_empty_rest_of_line();
}

void
s_long()
{
	cons(4);
}

void
s_int()
{
	cons(4);
}

void
s_lsym()
{
	register char *name;
	register char c;
	register char *p;
	register segT segment;
	expressionS exp;
	register symbolS *symbolP;

	/* we permit ANY expression: BSD4.2 demands constants */
	name = input_line_pointer;
	c = get_symbol_end();
	p = input_line_pointer;
	*p = c;
	SKIP_WHITESPACE();
	if ( * input_line_pointer != ',' ) {
		*p = 0;
		as_warn("Expected comma after name \"%s\"", name);
		*p = c;
		ignore_rest_of_line();
		return;
	}
	input_line_pointer ++;
	segment = expression (& exp);
	if (   segment != SEG_ABSOLUTE && segment != SEG_DATA &&
 segment != SEG_TEXT && segment != SEG_BSS) {
		as_bad("Bad expression: %s", seg_name [(int)segment]);
		ignore_rest_of_line();
		return;
	}
 know(   segment == SEG_ABSOLUTE || segment == SEG_DATA || segment == SEG_TEXT || segment == SEG_BSS );
	*p = 0;
	symbolP = symbol_new (name,(unsigned char)(seg_N_TYPE [(int) segment]),
 0, 0, (valueT)(exp . X_add_number), & zero_address_frag);
	*p = c;
	demand_empty_rest_of_line();
}

void
s_org()
{
	register segT segment;
	expressionS exp;
	register long int temp_fill;
	register char *p;
/*
 * Don't believe the documentation of BSD 4.2 AS.
 * There is no such thing as a sub-segment-relative origin.
 * Any absolute origin is given a warning, then assumed to be segment-relative.
 * Any segmented origin expression ("foo+42") had better be in the right
 * segment or the .org is ignored.
 *
 * BSD 4.2 AS warns if you try to .org backwards. We cannot because we
 * never know sub-segment sizes when we are reading code.
 * BSD will crash trying to emit -ve numbers of filler bytes in certain
 * .orgs. We don't crash, but see as-write for that code.
 */
/*
 * Don't make frag if need_pass_2==TRUE.
 */
	segment = get_known_segmented_expression(& exp);
	if ( *input_line_pointer == ',' ) {
		input_line_pointer ++;
		temp_fill = get_absolute_expression ();
	} else
		temp_fill = 0;
	if ( ! need_pass_2 ) {
		if (segment != now_seg && segment != SEG_ABSOLUTE)
			as_warn("Illegal segment \"%s\". Segment \"%s\" assumed.",
 seg_name [(int) segment], seg_name [(int) now_seg]);
		p = frag_var (rs_org, 1, 1, (relax_substateT)0, exp . X_add_symbol,
 exp . X_add_number, (char *)0);
		* p = temp_fill;
	} /* if (ok to make frag) */
	demand_empty_rest_of_line();
}

void
s_set()
{
	register char *name;
	register char delim;
	register char *end_name;
	register symbolS *symbolP;

	/*
	 * Especial apologies for the random logic:
	 * this just grew, and could be parsed much more simply!
	 * Dean in haste.
	 */
	name = input_line_pointer;
	delim = get_symbol_end();
	end_name = input_line_pointer;
	*end_name = delim;
	SKIP_WHITESPACE();
	if ( * input_line_pointer != ',' ) {
		*end_name = 0;
		as_warn("Expected comma after name \"%s\"", name);
		*end_name = delim;
		ignore_rest_of_line();
		return;