* config/m68k-parse.y: Likewise.
* config/obj-aout.c: Likewise.
* config/obj-bout.c: Likewise.
* config/obj-vms.c: Likewise.
* config/tc-tahoe.c: Likewise.
* config/tc-tic30.c: Likewise.
* config/tc-tic4x.c: Likewise.
* config/tc-tic54x.c: Likewise.
* config/tc-v850.c: Likewise.
* config/tc-vax.c: Likewise.
* config/te-delt88.h: Likewise.
* config/te-delta.h: Likewise.
* config/te-generic.h: Likewise.
* config/te-macos.h: Likewise.
* config/te-ppcnw.h: Likewise.
* config/te-psos.h: Likewise.
* config/te-sun3.h: Likewise.
* config/te-tmips.h: Likewise.
* config/xtensa-relax.c: Likewise.
and then shaved it down. I don't even know how it works. (Don't you find
my honesty refreshing? Devon E Bowen <bowen@cs.buffalo.edu>
- I don't allow uppercase letters in the precision descrpitors.
+ I don't allow uppercase letters in the precision descriptors.
i.e. 'f' and 'd' are allowed but 'F' and 'D' aren't. */
#include "as.h"
#include "safe-ctype.h"
/* Remap normal yacc parser interface names (yyparse, yylex, yyerror,
- etc), as well as gratuitiously global symbol names If other parser
+ etc), as well as gratuitously global symbol names If other parser
generators (bison, byacc, etc) produce additional global names that
conflict at link time, then those parser generators need to be
fixed instead of adding those names to this list. */
if (flag_readonly_data_in_text && (S_GET_SEGMENT (symbolP) == SEG_DATA))
{
S_SET_SEGMENT (symbolP, SEG_TEXT);
- } /* if pusing data into text */
+ } /* if pushing data into text */
resolve_symbol_value (symbolP);
if (flag_readonly_data_in_text && (S_GET_SEGMENT (symbolP) == SEG_DATA))
{
S_SET_SEGMENT (symbolP, SEG_TEXT);
- } /* if pusing data into text */
+ } /* if pushing data into text */
resolve_symbol_value (symbolP);
/* Write a Traceback Routine End record.
We *must* search the symbol table to find the next routine, since the
- assember has a way of reassembling the symbol table OUT OF ORDER Thus
+ assembler has a way of reassembling the symbol table OUT OF ORDER Thus
the next routine in the symbol list is not necessarily the next one in
memory. For debugging to work correctly we must know the size of the
routine. */
byte top_mode; /* Addressing mode byte. This byte, defines
which of the 11 modes opcode is. */
- char top_access; /* Access type wanted for this opperand
+ char top_access; /* Access type wanted for this operand
'b'branch ' 'no-instruction 'amrvw' */
char top_width; /* Operand width expected, one of "bwlq?-:!" */
can figure it out */
};
-/* The addressing modes for an operand. These numbers are the acutal values
- for certain modes, so be carefull if you screw with them. */
+/* The addressing modes for an operand. These numbers are the actual values
+ for certain modes, so be careful if you screw with them. */
#define TAHOE_DIRECT_REG (0x50)
#define TAHOE_REG_DEFERRED (0x60)
#define TAHOE_AUTO_DEC (0x7E)
#define TAHOE_AUTO_INC (0x8E)
#define TAHOE_AUTO_INC_DEFERRED (0x9E)
-/* INDEXED_REG is decided by the existance or lack of a [reg]. */
+/* INDEXED_REG is decided by the existence or lack of a [reg]. */
/* These are encoded into top_width when top_access=='b'
and it's a psuedo op. */
as in 0f123.456
or 0d1.234E-12 (see exp chars above)
Note: The Tahoe port doesn't support floating point constants. This is
- consistant with 'as' If it's needed, I can always add it later. */
+ consistent with 'as' If it's needed, I can always add it later. */
const char FLT_CHARS[] = "df";
/* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
{
1, 1, 0, 0
}, /* unused 2,3 */
-/* Another type of reversable branch. But this only has a word
+/* Another type of reversible branch. But this only has a word
displacement. */
{
1, 1, 0, 0
{
1, 1, 0, 0
}, /* unused 3,3 */
-/* These are the non reversable branches, all of which have a word
+/* These are the non reversible branches, all of which have a word
displacement. If I can't reach, branch over a byte branch, to a
jump that will reach. The jumped branch jumps over the reaching
branch, to continue with the flow of the program. It's like playing
* make the command look cute. ie: * foo ( r1 ) [ r0 ]
* If you like doing a lot of typing, try COBOL!
* Actually, this parser is a little weak all around. It's designed to be
- * used with compliers, so I emphisise correct decoding of valid code quickly
- * rather that catching every possable error.
+ * used with compliers, so I emphasize correct decoding of valid code quickly
+ * rather that catching every possible error.
* Note: This uses the expression function, so save input_line_pointer before
* calling.
*
* l longword
* q quadword (Even regs < 14 allowed) (if 12, you get a warning)
* - unconditional synthetic jbr operand
- * ? simple synthetic reversable branch operand
- * ! complex synthetic reversable branch operand
- * : complex synthetic non-reversable branch operand
+ * ? simple synthetic reversible branch operand
+ * ! complex synthetic reversible branch operand
+ * : complex synthetic non-reversible branch operand
*
* The '-?!:' letter 2's are not for external consumption. They are used
* by GAS for psuedo ops relaxing code.
* top_reg: -1, or register number. eg 7 = R7 or (R7)
* top_mode: The addressing mode byte. This byte, defines which of
* the 11 modes opcode is.
- * top_access: Access type wanted for this opperand 'b'branch ' '
+ * top_access: Access type wanted for this operand 'b'branch ' '
* no-instruction 'amrvw'
* top_width: Operand width expected, one of "bwlq?-:!"
* exp_of_operand: The expression as parsed by expression()
* top_dispsize: Number of bytes in the displacement if we can figure it
- * out and it's relavent.
+ * out and it's relevant.
*
* Need syntax checks built.
*/
auto-decremented '-' or neither ' '. */
int immediate = 0; /* 1 if '$' immediate mode */
int call_width = 0; /* If the caller casts the displacement */
- int abs_width = 0; /* The width of the absolute displacment */
+ int abs_width = 0; /* The width of the absolute displacement */
int com_width = 0; /* Displacement width required by branch */
int deferred = 0; /* 1 if '*' deferral is used */
byte disp_size = 0; /* How big is this operand. 0 == don't know */
/* Force words into a certain mode */
/* Bitch, Bitch, Bitch! */
/*
- * Using the ^ operator is ambigous. If I have an absolute label
+ * Using the ^ operator is ambiguous. If I have an absolute label
* called 'w' set to, say 2, and I have the expression 'w^1', do I get
* 1, forced to be in word displacement mode, or do I get the value of
* 'w' or'ed with 1 (3 in this case).
expP->X_add_number = 0;
really_none = 1;
case O_constant:
- /* for SEG_ABSOLUTE, we shouldnt need to set X_op_symbol,
+ /* for SEG_ABSOLUTE, we shouldn't need to set X_op_symbol,
X_add_symbol to any particular value. */
/* But, we will program defensively. Since this situation occurs
rarely so it costs us little to do so. */
/*
* We found a match! So let's pick up as many operands as the
* instruction wants, and even gripe if there are too many.
- * We expect comma to seperate each operand.
+ * We expect comma to separate each operand.
* We let instring track the text, while p tracks a part of the
* struct tot.
*/
to_seg == SEG_TEXT || \
to_seg == SEG_BSS);
is_undefined = (to_seg == SEG_UNKNOWN);
- /* Do we know how big this opperand is? */
+ /* Do we know how big this operand is? */
dispsize = operandP->top_dispsize;
pc_rel = 0;
- /* Deal with the branch possabilities. (Note, this doesn't include
+ /* Deal with the branch possibilities. (Note, this doesn't include
jumps.)*/
if (operandP->top_access == 'b')
{
branches to jumps, and let GAS fix them. */
/* These are "branches" what will always be branches around a jump
- to the correct addresss in real life.
+ to the correct address in real life.
If to_seg is SEG_ABSOLUTE, just encode the branch in,
else let GAS fix the address. */
{
/* The theory:
For SEG_ABSOLUTE, then mode is ABSOLUTE_ADDR, jump
- to that addresss (not pc_rel).
+ to that address (not pc_rel).
For other segs, address is a long word PC rel jump. */
case TAHOE_WIDTH_CONDITIONAL_JUMP:
/* b<cond> */
/* Is this a value out of this segment?
The first part of this conditional is a cludge to make gas
produce the same output as 'as' when there is a lable, in
- the current segment, displaceing a register. It's strange,
+ the current segment, displacing a register. It's strange,
and no one in their right mind would do it, but it's easy
to cludge. */
if ((dispsize == 0 && !pc_rel) ||
#include <varargs.h>
#endif
-/* Put here all non-digit non-letter charcters that may occur in an
+/* Put here all non-digit non-letter characters that may occur in an
operand. */
static char operand_special_chars[] = "%$-+(,)*._~/<>&^!:[@]";
static char *ordinal_names[] = {
should be possible to define a 32-bits pattern.
o .align fills all section with NOP's when used regardless if has
- been used in .text or .data. (However the .align is primarely
+ been used in .text or .data. (However the .align is primarily
intended used in .text sections. If you require something else,
use .align <size>,0x00)
- o .align: Implement a 'bu' insn if the number of nop's exeeds 4
+ o .align: Implement a 'bu' insn if the number of nop's exceeds 4
within the align frag. if(fragsize>4words) insert bu fragend+1
first.
/* Precision in LittleNums. */
#define MAX_PRECISION (4) /* Its a bit overkill for us, but the code
- reqires it... */
+ requires it... */
#define S_PRECISION (1) /* Short float constants 16-bit. */
#define F_PRECISION (2) /* Float and double types 32-bit. */
#define E_PRECISION (4) /* Extended precision, 64-bit (real 40-bit). */
We now have to left shift the other littlenums by the same amount,
propagating the shifted bits into the more significant littlenums.
- To save a lot of unecessary shifting we only have to consider
+ To save a lot of unnecessary shifting we only have to consider
two or three littlenums, since the greatest number of mantissa
bits required is 24 + 1 rounding bit. While two littlenums
provide 32 bits of precision, the most significant littlenum
{
unsigned long nop = NOP_OPCODE;
- /* Because we are talking lwords, not bytes, adjust aligment to do words */
+ /* Because we are talking lwords, not bytes, adjust alignment to do words */
alignment += 2;
if (alignment != 0 && !need_pass_2)
{
if (fill == NULL)
{
- /*if (subseg_text_p (now_seg))*/ /* FIXME: doesnt work for .text for some reason */
+ /*if (subseg_text_p (now_seg))*/ /* FIXME: doesn't work for .text for some reason */
frag_align_pattern( alignment, (const char *)&nop, sizeof(nop), max);
return 1;
/*else
frag_align_pattern (alignment, fill, len, max);
}
- /* Return 1 to skip the default aligment function */
+ /* Return 1 to skip the default alignment function */
return 1;
}
/* FIXME -- at one point TI tools used to output REL16
relocations, but I don't think the latest tools do at all
The current tools output extended relocations regardless of
- the addresing mode (I actually think that ".c_mode" is
+ the addressing mode (I actually think that ".c_mode" is
totally ignored in the latest tools). */
amode = far_mode;
emitting_long = 1;
/* [symbol] .usect "section-name", size-in-words
[, [blocking-flag] [, alignment-flag]]
- Unitialized section.
+ Uninitialized section.
Non-zero blocking means that if the section would cross a page (128-word)
boundary, it will be page-aligned.
Non-zero alignment aligns on a longword boundary.
return strcmp (a, b);
}
-/* Return the index of the first occurence of B in A, or zero if none
+/* Return the index of the first occurrence of B in A, or zero if none
assumes b is an integer char value as a string. Index is one-based. */
static int
return 0;
}
-/* Return the structrure size, given the stag. */
+/* Return the structure size, given the stag. */
static int
subsym_structsz (name, ignore)
}
/* Look up the substitution string replacement for the given symbol.
- Start with the innermost macro substituion table given and work
+ Start with the innermost macro substitution table given and work
outwards. */
static char *
{
/* Subscripted substitution symbol -- use just the
indicated portion of the string; the description
- kinda indicates that forced substituion is not
+ kinda indicates that forced substitution is not
supposed to be recursive, but I'm not sure. */
unsigned beg, len = 1; /* default to a single char */
char *newval = strcpy (xmalloc (strlen (value) + 1),
{ rX - rY, rZ }
etc
- and also parses constant epxressions whoes bits indicate the
+ and also parses constant expressions whoes bits indicate the
registers in the lists. The LSB in the expression refers to
- the lowest numbered permissable register in the register list,
+ the lowest numbered permissible register in the register list,
and so on upwards. System registers are considered to be very
high numbers. */
return operand->insert != NULL
? BFD_RELOC_V850_TDA_7_8_OFFSET /* sld.h/sst.h, operand: D8_7 */
- : BFD_RELOC_V850_TDA_7_7_OFFSET; /* sld.b/sst.b, opreand: D7 */
+ : BFD_RELOC_V850_TDA_7_7_OFFSET; /* sld.b/sst.b, operand: D7 */
}
/* Warning: The code in this function relies upon the definitions
if (ex.X_op != O_constant)
{
- /* If this register is actually occuring too early on
+ /* If this register is actually occurring too early on
the parsing of the instruction, (because another
field is missing) then report this. */
if (opindex_ptr[1] != 0
/*
* We found a match! So let's pick up as many operands as the
* instruction wants, and even gripe if there are too many.
- * We expect comma to seperate each operand.
+ * We expect comma to separate each operand.
* We let instring track the text, while p tracks a part of the
* struct vot.
*/
* There were a number of 'mismatched argument type' bugs to vip_op.
* The most general solution is to typedef each (of many) arguments.
* We used instead a typedef'd argument block. This is less modular
- * than using seperate return pointers for each result, but runs faster
+ * than using separate return pointers for each result, but runs faster
* on most engines, and seems to keep programmers happy. It will have
* to be done properly if we ever want to use vip_op as a general-purpose
* module (it was designed to be).
* We don't limit your choice of width character.
*
* DEC operands are hard work to parse. For example, '@' as the first
- * character means indirect (deferred) mode but elswhere it is a shift
+ * character means indirect (deferred) mode but elsewhere it is a shift
* operator.
* The long-winded explanation of how this is supposed to work is
* cancelled. Read a DEC vax manual.
*/
if (reg < 0)
{
- /* JF allow parenthasized expressions. I hope this works */
+ /* JF allow parenthesized expressions. I hope this works */
paren = 0;
while (*q != ')')
q++;
*/
\f
/*
- * Case of Rn. We seperate this one because it has a few special
+ * Case of Rn. We separate this one because it has a few special
* errors the remaining modes lack.
*
* in: at optional
#define COFF_NOLOAD_PROBLEM 1
-/* Added these, because if we don't know what we're targetting we may
+/* Added these, because if we don't know what we're targeting we may
need an assembler version of libgcc, and that will use local
labels. */
#define LOCAL_LABELS_DOLLAR 1
#define COFF_NOLOAD_PROBLEM 1
#define COFF_COMMON_ADDEND 1
-/* Added these, because if we don't know what we're targetting we may
+/* Added these, because if we don't know what we're targeting we may
need an assembler version of libgcc, and that will use local
labels. */
#define LOCAL_LABELS_DOLLAR 1
* compile, and copying as an aid for testing and porting. xoxorich.
*/
-/* Added these, because if we don't know what we're targetting we may
+/* Added these, because if we don't know what we're targeting we may
need an assembler version of libgcc, and that will use local
labels. */
#define LOCAL_LABELS_DOLLAR 1
#define TE_POWERMAC 1
-/* Added these, because if we don't know what we're targetting we may
+/* Added these, because if we don't know what we're targeting we may
need an assembler version of libgcc, and that will use local
labels. */
#define LOCAL_LABELS_DOLLAR 1
the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA. */
-/* Added these, because if we don't know what we're targetting we may
+/* Added these, because if we don't know what we're targeting we may
need an assembler version of libgcc, and that will use local
labels. */
#define LOCAL_LABELS_DOLLAR 1
#define TE_PSOS
-/* Added these, because if we don't know what we're targetting we may
+/* Added these, because if we don't know what we're targeting we may
need an assembler version of libgcc, and that will use local
labels. */
#define LOCAL_LABELS_DOLLAR 1
/* This header file contains the #defines specific
to SUN computer SUN 3 series computers. (The only kind
- we have around here, unfortunatly.)
+ we have around here, unfortunately.)
Rumor has it that this file will work on the Sun-2 if the assembler
is called with -m68010 This is not tested. */
Created by Koundinya.K < kk@ddeorg.soft.net > with the help of
Ian Lance Taylor, Cygnus Support, <ian@cygnus.com>. */
-/* Added these, because if we don't know what we're targetting we may
+/* Added these, because if we don't know what we're targeting we may
need an assembler version of libgcc, and that will use local
labels. */
/* The widen_spec_list is a list of valid substitutions that generate
wider representations. These are generally used to specify
replacements for instructions whose immediates do not fit their
- encodings. A valid transition may require mutiple steps of
+ encodings. A valid transition may require multiple steps of
one-to-one instruction replacements with a final multiple
instruction replacement. As an example, here are the transitions
required to replace an 'addi.n' with an 'addi', 'addmi'.
projects / binutils-gdb.git / commitdiff