fighting bitrot in a major way

1 files changed, 148 insertions, 71 deletions

diff --git a/gas/config/tc-i386.c b/gas/config/tc-i386.c
index 42398ae..92b4b4a 100644
--- a/gas/config/tc-i386.c
+++ b/gas/config/tc-i386.c
@@ -34,46 +34,47 @@
 
 typedef struct {
 	/* TM holds the template for the insn were currently assembling. */
-	template          tm;
+	template tm;
 	/* SUFFIX holds the opcode suffix (e.g. 'l' for 'movl') if given. */
-	char              suffix;
+	char suffix;
 	/* Operands are coded with OPERANDS, TYPES, DISPS, IMMS, and REGS. */
 	
 	/* OPERANDS gives the number of given operands. */
-	unsigned int               operands;
+	unsigned int operands;
 	
 	/* REG_OPERANDS, DISP_OPERANDS, MEM_OPERANDS, IMM_OPERANDS give the number of
 	   given register, displacement, memory operands and immediate operands. */
-	unsigned int               reg_operands, disp_operands, mem_operands, imm_operands;
+	unsigned int reg_operands, disp_operands, mem_operands, imm_operands;
 	
 	/* TYPES [i] is the type (see above #defines) which tells us how to
 	   search through DISPS [i] & IMMS [i] & REGS [i] for the required
 	   operand. */
-	unsigned int               types [MAX_OPERANDS];
+	unsigned int types[MAX_OPERANDS];
 	
 	/* Displacements (if given) for each operand. */
-	expressionS       * disps [MAX_OPERANDS];
+	expressionS *disps[MAX_OPERANDS];
 	
 	/* Immediate operands (if given) for each operand. */
-	expressionS       * imms [MAX_OPERANDS];
+	expressionS *imms[MAX_OPERANDS];
 	
 	/* Register operands (if given) for each operand. */
-	reg_entry         * regs [MAX_OPERANDS];
+	reg_entry *regs[MAX_OPERANDS];
 	
 	/* BASE_REG, INDEX_REG, and LOG2_SCALE_FACTOR are used to encode
 	   the base index byte below.  */
-	reg_entry         * base_reg;
-	reg_entry         * index_reg;
-	unsigned int                log2_scale_factor;
+	reg_entry *base_reg;
+	reg_entry *index_reg;
+	unsigned int log2_scale_factor;
 	
 	/* SEG gives the seg_entry of this insn.  It is equal to zero unless
 	   an explicit segment override is given. */
-	seg_entry         * seg;	/* segment for memory operands (if given) */
+	const seg_entry *seg;	/* segment for memory operands (if given) */
 	
 	/* PREFIX holds all the given prefix opcodes (usually null).
 	   PREFIXES is the size of PREFIX. */
-	char              prefix [MAX_PREFIXES];
-	unsigned int              prefixes;
+ /* richfix: really unsigned? */
+	unsigned char prefix[MAX_PREFIXES];
+	unsigned int prefixes;
 	
 	/* RM and IB are the modrm byte and the base index byte where the addressing
 	   modes of this insn are encoded. */
@@ -203,14 +204,28 @@ const relax_typeS md_relax_table[] = {
 #if __STDC__ == 1
 
 static char *output_invalid(int c);
+static int fits_in_signed_byte(long num);
+static int fits_in_signed_word(long num);
+static int fits_in_unsigned_byte(long num);
+static int fits_in_unsigned_word(long num);
 static int i386_operand(char *operand_string);
+static int smallest_imm_type(long num);
 static reg_entry *parse_register(char *reg_string);
+static unsigned long mode_from_disp_size(unsigned long t);
+static unsigned long opcode_suffix_to_type(unsigned long s);
 
 #else /* not __STDC__ */
 
 static char *output_invalid();
+static int fits_in_signed_byte();
+static int fits_in_signed_word();
+static int fits_in_unsigned_byte();
+static int fits_in_unsigned_word();
 static int i386_operand();
+static int smallest_imm_type();
 static reg_entry *parse_register();
+static unsigned long mode_from_disp_size();
+static unsigned long opcode_suffix_to_type();
 
 #endif /* not __STDC__ */
 
@@ -317,11 +332,11 @@ void md_begin ()
 	{  
 		register unsigned int c;
 		
-		bzero (opcode_chars, sizeof(opcode_chars));
-		bzero (operand_chars, sizeof(operand_chars));
-		bzero (space_chars, sizeof(space_chars));
-		bzero (identifier_chars, sizeof(identifier_chars));
-		bzero (digit_chars, sizeof(digit_chars));
+		memset(opcode_chars, '\0', sizeof(opcode_chars));
+		memset(operand_chars, '\0', sizeof(operand_chars));
+		memset(space_chars, '\0', sizeof(space_chars));
+		memset(identifier_chars, '\0', sizeof(identifier_chars));
+		memset(digit_chars, '\0', sizeof(digit_chars));
 		
 		for (c = 0; c < 256; c++) {
 			if (islower(c) || isdigit(c)) {
@@ -473,15 +488,15 @@ void md_assemble (line)
 char *line;
 {
 	/* Holds temlate once we've found it. */
-	register template * t;
+	register template *t;
 	
 	/* Possible templates for current insn */
 	templates *current_templates = (templates *) 0;
 	
 	/* Initialize globals. */
-	bzero (&i, sizeof(i));
-	bzero (disp_expressions, sizeof(disp_expressions));
-	bzero (im_expressions, sizeof(im_expressions));
+	memset(&i, '\0', sizeof(i));
+	memset(disp_expressions, '\0', sizeof(disp_expressions));
+	memset(im_expressions, '\0', sizeof(im_expressions));
 	save_stack_p = save_stack;	/* reset stack pointer */
 	
 	/* Fist parse an opcode & call i386_operand for the operands.
@@ -638,12 +653,12 @@ char *line;
 				
 				/* now *l must be either ',' or END_OF_INSN */
 				if (*l == ',') {
-					if (*++l == END_OF_INSN) {		/* just skip it, if it's \n complain */
+					if (*++l == END_OF_INSN) { /* just skip it, if it's \n complain */
 						goto expecting_operand_after_comma;
 					}
 					expecting_operand = 1;
 				}
-			} while (*l != END_OF_INSN);		/* until we get end of insn */
+			} while (*l != END_OF_INSN); /* until we get end of insn */
 		}
 	}
 	
@@ -676,7 +691,7 @@ char *line;
 	     ( ((t0 & t1 & (Reg)) == 0 && (m0 & m1 & (Reg)) == 0) || \
 	      ((t0 & t1) & (m0 & m1) & (Reg)) \
 	      ) : 1)
-		{
+	      {
 			register unsigned int overlap0, overlap1;
 			expressionS * exp;
 			unsigned int overlap2;
@@ -746,7 +761,7 @@ char *line;
 			}
 			
 			/* Copy the template we found (we may change it!). */
-			bcopy (t, &i.tm, sizeof (template));
+			memcpy(&i.tm, t, sizeof(template));
 			t = &i.tm;			/* alter new copy of template */
 			
 			/* If there's no opcode suffix we try to invent one based on register
@@ -917,7 +932,7 @@ char *line;
 							if (i.base_reg == esp && ! i.index_reg) {
 								/* <disp>(%esp) becomes two byte modrm with no index register. */
 								i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
-								i.rm.mode = MODE_FROM_DISP_SIZE (i.types[o]);
+								i.rm.mode = mode_from_disp_size(i.types[o]);
 								i.bi.base = ESP_REG_NUM;
 								i.bi.index = NO_INDEX_REGISTER;
 								i.bi.scale = 0;		/* Must be zero! */
@@ -929,7 +944,7 @@ char *line;
 									/* fake_zero_displacement code does not set this. */
 									i.types[o] |= Disp8;
 								}
-								i.rm.mode = MODE_FROM_DISP_SIZE (i.types[o]);
+								i.rm.mode = mode_from_disp_size(i.types[o]);
 								i.rm.regmem = EBP_REG_NUM;
 							} else if (! i.base_reg && (i.types[o] & BaseIndex)) {
 								/* There are three cases here.
@@ -961,7 +976,7 @@ char *line;
 							} else {
 								/* It's not a special case; rev'em up. */
 								i.rm.regmem = i.base_reg->reg_num;
-								i.rm.mode = MODE_FROM_DISP_SIZE (i.types[o]);
+								i.rm.mode = mode_from_disp_size(i.types[o]);
 								if (i.index_reg) {
 									i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
 									i.bi.base = i.base_reg->reg_num;
@@ -970,7 +985,7 @@ char *line;
 									if (i.base_reg == ebp && i.disp_operands == 0) { /* pace */
 										fake_zero_displacement = 1;
 										i.types[o] |= Disp8;
-										i.rm.mode = MODE_FROM_DISP_SIZE (i.types[o]);
+										i.rm.mode = mode_from_disp_size(i.types[o]);
 									}
 								}
 							}
@@ -987,15 +1002,15 @@ char *line;
 							
 							/* Select the correct segment for the memory operand. */
 							if (i.seg) {
-								const unsigned int seg_index;
-								const seg_entry * default_seg;
+								unsigned int seg_index;
+								const seg_entry *default_seg;
 								
 								if (i.rm.regmem == ESCAPE_TO_TWO_BYTE_ADDRESSING) {
 									seg_index = (i.rm.mode<<3) | i.bi.base;
-									default_seg = two_byte_segment_defaults [seg_index];
+									default_seg = two_byte_segment_defaults[seg_index];
 								} else {
 									seg_index = (i.rm.mode<<3) | i.rm.regmem;
-									default_seg = one_byte_segment_defaults [seg_index];
+									default_seg = one_byte_segment_defaults[seg_index];
 								}
 								/* If the specified segment is not the default, use an
 								   opcode prefix to select it */
@@ -1054,12 +1069,12 @@ char *line;
 			
 			switch (i.disps[0]->X_seg) {
 			case SEG_ABSOLUTE:
-				if (FITS_IN_SIGNED_BYTE (n)) {
+				if (fits_in_signed_byte(n)) {
 					p = frag_more (2);
 					p[0] = t->base_opcode;
 					p[1] = n;
 #if 0 /* leave out 16 bit jumps - pace */
-				} else if (FITS_IN_SIGNED_WORD (n)) {
+				} else if (fits_in_signed_word(n)) {
 					p = frag_more (4);
 					p[0] = WORD_PREFIX_OPCODE;
 					p[1] = t->base_opcode;
@@ -1106,7 +1121,7 @@ char *line;
 			int size = (t->opcode_modifier & JumpByte) ? 1 : 4;
 			int n = i.disps[0]->X_add_number;
 			
-			if (FITS_IN_UNSIGNED_BYTE(t->base_opcode)) {
+			if (fits_in_unsigned_byte(t->base_opcode)) {
 				FRAG_APPEND_1_CHAR (t->base_opcode);
 			} else {
 				p = frag_more (2);	/* opcode can be at most two bytes */
@@ -1119,7 +1134,7 @@ char *line;
 			switch (i.disps[0]->X_seg) {
 			case SEG_ABSOLUTE:
 				md_number_to_chars (p, n, size);
-				if (size == 1 && ! FITS_IN_SIGNED_BYTE (n)) {
+				if (size == 1 && ! fits_in_signed_byte(n)) {
 					as_bad("loop/jecx only takes byte displacement; %d shortened to %d",
 					       n, *p);
 				}
@@ -1145,7 +1160,7 @@ char *line;
 			md_number_to_chars (p + 5, i.imms[0]->X_add_number, 2);
 		} else {
 			/* Output normal instructions here. */
-			register char *q;
+			unsigned char *q;
 			
 			/* First the prefix bytes. */
 			for (q = i.prefix; q < i.prefix + i.prefixes; q++) {
@@ -1154,9 +1169,9 @@ char *line;
 			}
 			
 			/* Now the opcode; be careful about word order here! */
-			if (FITS_IN_UNSIGNED_BYTE(t->base_opcode)) {
+			if (fits_in_unsigned_byte(t->base_opcode)) {
 				FRAG_APPEND_1_CHAR (t->base_opcode);
-			} else if (FITS_IN_UNSIGNED_WORD(t->base_opcode)) {
+			} else if (fits_in_unsigned_word(t->base_opcode)) {
 				p =  frag_more (2);
 				/* put out high byte first: can't use md_number_to_chars! */
 				*p++ = (t->base_opcode >> 8) & 0xff;
@@ -1271,8 +1286,8 @@ char *operand_string;
 	char * end_of_operand_string = operand_string + strlen(operand_string);
 	
 	/* Start and end of displacement string expression (if found). */
-	char * displacement_string_start = 0;
-	char * displacement_string_end;
+	char *displacement_string_start = NULL;
+	char *displacement_string_end = NULL;
 	
 	/* We check for an absolute prefix (differentiating,
 	   for example, 'jmp pc_relative_label' from 'jmp *absolute_label'. */
@@ -1283,8 +1298,8 @@ char *operand_string;
 	
 	/* Check if operand is a register. */
 	if (*op_string == REGISTER_PREFIX) {
-		register reg_entry * r;
-		if (! (r = parse_register (op_string))) {
+		register reg_entry *r;
+		if (!(r = parse_register (op_string))) {
 			as_bad("bad register name ('%s')", op_string);
 			return 0;
 		}
@@ -1323,19 +1338,22 @@ char *operand_string;
 		i.regs[this_operand] = r;
 		i.reg_operands++;
 	} else if (*op_string == IMMEDIATE_PREFIX) { /* ... or an immediate */
-		char * save_input_line_pointer;
-		register expressionS *exp;
-		segT exp_seg;
+		char *save_input_line_pointer;
+		segT exp_seg = SEG_GOOF;
+		expressionS *exp;
+
 		if (i.imm_operands == MAX_IMMEDIATE_OPERANDS) {
 			as_bad("only 1 or 2 immediate operands are allowed");
 			return 0;
 		}
+
 		exp = &im_expressions[i.imm_operands++];
-		i.imms [this_operand] = exp;
+		i.imms[this_operand] = exp;
 		save_input_line_pointer = input_line_pointer;
 		input_line_pointer = ++op_string;        /* must advance op_string! */
-		exp_seg = expression (exp);
+		exp_seg = expression(exp);
 		input_line_pointer = save_input_line_pointer;
+
 		switch (exp_seg) {
 		case SEG_ABSENT:    /* missing or bad expr becomes absolute 0 */
 			as_bad("missing or invalid immediate expression '%s' taken as 0",
@@ -1347,7 +1365,7 @@ char *operand_string;
 			i.types[this_operand] |= Imm;
 			break;
 		case SEG_ABSOLUTE:
-			i.types[this_operand] |= SMALLEST_IMM_TYPE (exp->X_add_number);
+			i.types[this_operand] |= smallest_imm_type(exp->X_add_number);
 			break;
 		case SEG_TEXT: case SEG_DATA: case SEG_BSS: case SEG_UNKNOWN:
 			i.types[this_operand] |= Imm32; /* this is an address ==> 32bit */
@@ -1511,16 +1529,16 @@ char *operand_string;
 		   assuming displacement_string_start and displacement_string_end
 		   are meaningful. */
 		if (displacement_string_start) {
-			register expressionS * exp;
-			segT exp_seg;
-			char * save_input_line_pointer;
+			register expressionS *exp;
+			segT exp_seg = SEG_GOOF;
+			char *save_input_line_pointer;
 			exp = &disp_expressions[i.disp_operands];
 			i.disps [this_operand] = exp;
 			i.disp_operands++;
 			save_input_line_pointer = input_line_pointer;
 			input_line_pointer = displacement_string_start;
 			END_STRING_AND_SAVE (displacement_string_end);
-			exp_seg = expression (exp);
+			exp_seg = expression(exp);
 			if(*input_line_pointer)
 			    as_bad("Ignoring junk '%s' after expression",input_line_pointer);
 			RESTORE_END_STRING (displacement_string_end);
@@ -1641,10 +1659,11 @@ void
 object_headers *headers;
 register fragS *	fragP;
 {
-	register unsigned char * opcode;
-	unsigned char * where_to_put_displacement;
-	unsigned int target_address, opcode_address;
-	unsigned int extension;
+	register unsigned char *opcode;
+	unsigned char *where_to_put_displacement = NULL;
+	unsigned int target_address;
+	unsigned int opcode_address;
+	unsigned int extension = 0;
 	int displacement_from_opcode_start;
 	
 	opcode = (unsigned char *) fragP -> fr_opcode;
@@ -1860,26 +1879,24 @@ relax_addressT segment_address_in_file;
 	 */
 	
 	static unsigned char nbytes_r_length [] = { 42, 0, 1, 42, 2 };
-	long r_index;
+	long r_symbolnum;
 	
 	know(fixP->fx_addsy != NULL);
 	
-	r_index = (S_IS_DEFINED(fixP->fx_addsy)
-		   ? S_GET_TYPE(fixP->fx_addsy)
-		   : fixP->fx_addsy->sy_number);
-	
-	/* this is easy */
 	md_number_to_chars(where,
 			   fixP->fx_frag->fr_address + fixP->fx_where - segment_address_in_file,
 			   4);
 	
-	/* now the fun stuff */
-	where[4] = r_index  & 0x0ff;
-	where[5] = (r_index >> 8) & 0x0ff;
-	where[6] = (r_index >> 16) & 0x0ff;
+	r_symbolnum = (S_IS_DEFINED(fixP->fx_addsy)
+		       ? S_GET_TYPE(fixP->fx_addsy)
+		       : fixP->fx_addsy->sy_number);
+	
+	where[6] = (r_symbolnum >> 16) & 0x0ff;
+	where[5] = (r_symbolnum >> 8) & 0x0ff;
+	where[4] = r_symbolnum & 0x0ff;
 	where[7] = ((((!S_IS_DEFINED(fixP->fx_addsy)) << 3)  & 0x08)
 		    | ((nbytes_r_length[fixP->fx_size] << 1) & 0x06)
-		    | ((fixP->fx_pcrel << 0) & 0x01) & 0x0f);
+		    | (((fixP->fx_pcrel << 0) & 0x01) & 0x0f));
 	
 	return;
 } /* tc_aout_fix_to_chars() */
@@ -2006,6 +2023,66 @@ fixS *fixP;
 	return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
 }
 
+ /* these were macros, but I don't trust macros that eval their
+    arguments more than once.  Besides, gcc can static inline them.
+    xoxorich.  */
+
+static unsigned long mode_from_disp_size(t)
+unsigned long t;
+{
+	return((t & (Disp8))
+	       ? 1
+	       : ((t & (Disp32)) ? 2 : 0));
+} /* mode_from_disp_size() */
+
+/* convert opcode suffix ('b' 'w' 'l' typically) into type specifyer */
+
+static unsigned long opcode_suffix_to_type(s)
+unsigned long s;
+{
+	return(s == BYTE_OPCODE_SUFFIX
+	       ? Byte : (s == WORD_OPCODE_SUFFIX
+			 ? Word : DWord));
+} /* opcode_suffix_to_type() */
+
+static int fits_in_signed_byte(num)
+long num;
+{
+	return((num >= -128) && (num <= 127));
+} /* fits_in_signed_byte() */
+
+static int fits_in_unsigned_byte(num)
+long num;
+{
+	return((num & 0xff) == num);
+} /* fits_in_unsigned_byte() */
+
+static int fits_in_unsigned_word(num)
+long num;
+{
+	return((num & 0xffff) == num);
+} /* fits_in_unsigned_word() */
+
+static int fits_in_signed_word(num)
+long num;
+{
+	return((-32768 <= num) && (num <= 32767));
+} /* fits_in_signed_word() */
+
+static int smallest_imm_type(num)
+long num;
+{
+	return((num == 1)
+	       ? (Imm1|Imm8|Imm8S|Imm16|Imm32)
+	       : (fits_in_signed_byte(num)
+		  ? (Imm8S|Imm8|Imm16|Imm32)
+		  : (fits_in_unsigned_byte(num)
+		     ? (Imm8|Imm16|Imm32)
+		     : ((fits_in_signed_word(num) || fits_in_unsigned_word(num))
+			? (Imm16|Imm32)
+			: (Imm32)))));
+} /* smallest_imm_type() */
+
 /*
  * Local Variables:
  * comment-column: 0