From: Ian Lance Taylor Date: Mon, 15 Mar 1993 23:58:22 +0000 (+0000) Subject: * write.c (write_contents): Compute the relocs before writing out X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=3d3c503955d3161a4fa38700d8de05c04b263215;p=binutils-gdb.git * write.c (write_contents): Compute the relocs before writing out the section contents. * config/obj-ecoff.h, config/obj-ecoff.c: Numerous changes to get symbol table and values right. * config/tc-mips.h (LOCAL_LABEL): If OBJ_ECOFF, any label starting with $L is local. * config/tc-mips.c (tc_gen_reloc): If OBJ_ECOFF, adjust the addend by the section vma. * config/z8k.mt (TARG_CPU_DEPENDENTS): The relevant file is z8k-opc.h, not z8k.h. --- diff --git a/gas/ChangeLog b/gas/ChangeLog index ae505441f98..bfc4e5426fe 100644 --- a/gas/ChangeLog +++ b/gas/ChangeLog @@ -1,5 +1,17 @@ Mon Mar 15 12:17:28 1993 Ian Lance Taylor (ian@cygnus.com) + * write.c (write_contents): Compute the relocs before writing out + the section contents. + * config/obj-ecoff.h, config/obj-ecoff.c: Numerous changes to get + symbol table and values right. + * config/tc-mips.h (LOCAL_LABEL): If OBJ_ECOFF, any label starting + with $L is local. + * config/tc-mips.c (tc_gen_reloc): If OBJ_ECOFF, adjust the addend + by the section vma. + + * config/z8k.mt (TARG_CPU_DEPENDENTS): The relevant file is + z8k-opc.h, not z8k.h. + * config/obj-coffbfd.c (obj_coff_endef): Correct test for .bf symbol. diff --git a/gas/config/obj-ecoff.c b/gas/config/obj-ecoff.c new file mode 100644 index 00000000000..1e29ab874c9 --- /dev/null +++ b/gas/config/obj-ecoff.c @@ -0,0 +1,4822 @@ +/* ECOFF object file format. + Copyright (C) 1993 Free Software Foundation, Inc. + Contributed by Cygnus Support. + This file was put together by Ian Lance Taylor . A + good deal of it comes directly from mips-tfile.c, by Michael + Meissner . + + This file is part of GAS. + + GAS is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + GAS is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GAS; see the file COPYING. If not, write to + the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include "as.h" +#include "coff/internal.h" +#include "coff/mips.h" +#include "coff/sym.h" +#include "coff/symconst.h" +#include "coff/ecoff-ext.h" +#include "aout/stab_gnu.h" +#include "../bfd/libecoff.h" + +/* Why isn't this in coff/sym.h? */ +#define ST_RFDESCAPE 0xfff + +/* The ECOFF file format uses COFF style sections, but with a unique + debugging format. We just build generic BFD sections since BFD + knows how to write them out. The debugging format, however, we + must construct here; all BFD knows at the moment is to write it out + as a large block of data. + + We support both COFF style debugging and stabs debugging (the stabs + symbols are encapsulated in COFF symbols). This should let us + handle anything the compiler might throw at us. Parsing the COFF + and stabs debugging information is similar to work done by COFF and + a.out targets, but since the result is completely different the + code is not shared. */ + +/* Here is a brief description of the MIPS ECOFF symbol table, by + Michael Meissner. The MIPS symbol table has the following pieces: + + Symbolic Header + | + +-- Auxiliary Symbols + | + +-- Dense number table + | + +-- Optimizer Symbols + | + +-- External Strings + | + +-- External Symbols + | + +-- Relative file descriptors + | + +-- File table + | + +-- Procedure table + | + +-- Line number table + | + +-- Local Strings + | + +-- Local Symbols + + The symbolic header points to each of the other tables, and also + contains the number of entries. It also contains a magic number + and MIPS compiler version number, such as 2.0. + + The auxiliary table is a series of 32 bit integers, that are + referenced as needed from the local symbol table. Unlike standard + COFF, the aux. information does not follow the symbol that uses + it, but rather is a separate table. In theory, this would allow + the MIPS compilers to collapse duplicate aux. entries, but I've not + noticed this happening with the 1.31 compiler suite. The different + types of aux. entries are: + + 1) dnLow: Low bound on array dimension. + + 2) dnHigh: High bound on array dimension. + + 3) isym: Index to the local symbol which is the start of the + function for the end of function first aux. entry. + + 4) width: Width of structures and bitfields. + + 5) count: Count of ranges for variant part. + + 6) rndx: A relative index into the symbol table. The relative + index field has two parts: rfd which is a pointer into the + relative file index table or ST_RFDESCAPE which says the next + aux. entry is the file number, and index: which is the pointer + into the local symbol within a given file table. This is for + things like references to types defined in another file. + + 7) Type information: This is like the COFF type bits, except it + is 32 bits instead of 16; they still have room to add new + basic types; and they can handle more than 6 levels of array, + pointer, function, etc. Each type information field contains + the following structure members: + + a) fBitfield: a bit that says this is a bitfield, and the + size in bits follows as the next aux. entry. + + b) continued: a bit that says the next aux. entry is a + continuation of the current type information (in case + there are more than 6 levels of array/ptr/function). + + c) bt: an integer containing the base type before adding + array, pointer, function, etc. qualifiers. The + current base types that I have documentation for are: + + btNil -- undefined + btAdr -- address - integer same size as ptr + btChar -- character + btUChar -- unsigned character + btShort -- short + btUShort -- unsigned short + btInt -- int + btUInt -- unsigned int + btLong -- long + btULong -- unsigned long + btFloat -- float (real) + btDouble -- Double (real) + btStruct -- Structure (Record) + btUnion -- Union (variant) + btEnum -- Enumerated + btTypedef -- defined via a typedef isymRef + btRange -- subrange of int + btSet -- pascal sets + btComplex -- fortran complex + btDComplex -- fortran double complex + btIndirect -- forward or unnamed typedef + btFixedDec -- Fixed Decimal + btFloatDec -- Float Decimal + btString -- Varying Length Character String + btBit -- Aligned Bit String + btPicture -- Picture + btVoid -- Void (MIPS cc revision >= 2.00) + + d) tq0 - tq5: type qualifier fields as needed. The + current type qualifier fields I have documentation for + are: + + tqNil -- no more qualifiers + tqPtr -- pointer + tqProc -- procedure + tqArray -- array + tqFar -- 8086 far pointers + tqVol -- volatile + + + The dense number table is used in the front ends, and disappears by + the time the .o is created. + + With the 1.31 compiler suite, the optimization symbols don't seem + to be used as far as I can tell. + + The linker is the first entity that creates the relative file + descriptor table, and I believe it is used so that the individual + file table pointers don't have to be rewritten when the objects are + merged together into the program file. + + Unlike COFF, the basic symbol & string tables are split into + external and local symbols/strings. The relocation information + only goes off of the external symbol table, and the debug + information only goes off of the internal symbol table. The + external symbols can have links to an appropriate file index and + symbol within the file to give it the appropriate type information. + Because of this, the external symbols are actually larger than the + internal symbols (to contain the link information), and contain the + local symbol structure as a member, though this member is not the + first member of the external symbol structure (!). I suspect this + split is to make strip easier to deal with. + + Each file table has offsets for where the line numbers, local + strings, local symbols, and procedure table starts from within the + global tables, and the indexs are reset to 0 for each of those + tables for the file. + + The procedure table contains the binary equivalents of the .ent + (start of the function address), .frame (what register is the + virtual frame pointer, constant offset from the register to obtain + the VFP, and what register holds the return address), .mask/.fmask + (bitmask of saved registers, and where the first register is stored + relative to the VFP) assembler directives. It also contains the + low and high bounds of the line numbers if debugging is turned on. + + The line number table is a compressed form of the normal COFF line + table. Each line number entry is either 1 or 3 bytes long, and + contains a signed delta from the previous line, and an unsigned + count of the number of instructions this statement takes. + + The local symbol table contains the following fields: + + 1) iss: index to the local string table giving the name of the + symbol. + + 2) value: value of the symbol (address, register number, etc.). + + 3) st: symbol type. The current symbol types are: + + stNil -- Nuthin' special + stGlobal -- external symbol + stStatic -- static + stParam -- procedure argument + stLocal -- local variable + stLabel -- label + stProc -- External Procedure + stBlock -- beginning of block + stEnd -- end (of anything) + stMember -- member (of anything) + stTypedef -- type definition + stFile -- file name + stRegReloc -- register relocation + stForward -- forwarding address + stStaticProc -- Static procedure + stConstant -- const + + 4) sc: storage class. The current storage classes are: + + scText -- text symbol + scData -- initialized data symbol + scBss -- un-initialized data symbol + scRegister -- value of symbol is register number + scAbs -- value of symbol is absolute + scUndefined -- who knows? + scCdbLocal -- variable's value is IN se->va.?? + scBits -- this is a bit field + scCdbSystem -- value is IN debugger's address space + scRegImage -- register value saved on stack + scInfo -- symbol contains debugger information + scUserStruct -- addr in struct user for current process + scSData -- load time only small data + scSBss -- load time only small common + scRData -- load time only read only data + scVar -- Var parameter (fortranpascal) + scCommon -- common variable + scSCommon -- small common + scVarRegister -- Var parameter in a register + scVariant -- Variant record + scSUndefined -- small undefined(external) data + scInit -- .init section symbol + + 5) index: pointer to a local symbol or aux. entry. + + + + For the following program: + + #include + + main(){ + printf("Hello World!\n"); + return 0; + } + + Mips-tdump produces the following information: + + Global file header: + magic number 0x162 + # sections 2 + timestamp 645311799, Wed Jun 13 17:16:39 1990 + symbolic header offset 284 + symbolic header size 96 + optional header 56 + flags 0x0 + + Symbolic header, magic number = 0x7009, vstamp = 1.31: + + Info Offset Number Bytes + ==== ====== ====== ===== + + Line numbers 380 4 4 [13] + Dense numbers 0 0 0 + Procedures Tables 384 1 52 + Local Symbols 436 16 192 + Optimization Symbols 0 0 0 + Auxiliary Symbols 628 39 156 + Local Strings 784 80 80 + External Strings 864 144 144 + File Tables 1008 2 144 + Relative Files 0 0 0 + External Symbols 1152 20 320 + + File #0, "hello2.c" + + Name index = 1 Readin = No + Merge = No Endian = LITTLE + Debug level = G2 Language = C + Adr = 0x00000000 + + Info Start Number Size Offset + ==== ===== ====== ==== ====== + Local strings 0 15 15 784 + Local symbols 0 6 72 436 + Line numbers 0 13 13 380 + Optimization symbols 0 0 0 0 + Procedures 0 1 52 384 + Auxiliary symbols 0 14 56 628 + Relative Files 0 0 0 0 + + There are 6 local symbols, starting at 436 + + Symbol# 0: "hello2.c" + End+1 symbol = 6 + String index = 1 + Storage class = Text Index = 6 + Symbol type = File Value = 0 + + Symbol# 1: "main" + End+1 symbol = 5 + Type = int + String index = 10 + Storage class = Text Index = 12 + Symbol type = Proc Value = 0 + + Symbol# 2: "" + End+1 symbol = 4 + String index = 0 + Storage class = Text Index = 4 + Symbol type = Block Value = 8 + + Symbol# 3: "" + First symbol = 2 + String index = 0 + Storage class = Text Index = 2 + Symbol type = End Value = 28 + + Symbol# 4: "main" + First symbol = 1 + String index = 10 + Storage class = Text Index = 1 + Symbol type = End Value = 52 + + Symbol# 5: "hello2.c" + First symbol = 0 + String index = 1 + Storage class = Text Index = 0 + Symbol type = End Value = 0 + + There are 14 auxiliary table entries, starting at 628. + + * #0 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0] + * #1 24, [ 24/ 0], [ 6 0:0 0:0:0:0:0:0] + * #2 8, [ 8/ 0], [ 2 0:0 0:0:0:0:0:0] + * #3 16, [ 16/ 0], [ 4 0:0 0:0:0:0:0:0] + * #4 24, [ 24/ 0], [ 6 0:0 0:0:0:0:0:0] + * #5 32, [ 32/ 0], [ 8 0:0 0:0:0:0:0:0] + * #6 40, [ 40/ 0], [10 0:0 0:0:0:0:0:0] + * #7 44, [ 44/ 0], [11 0:0 0:0:0:0:0:0] + * #8 12, [ 12/ 0], [ 3 0:0 0:0:0:0:0:0] + * #9 20, [ 20/ 0], [ 5 0:0 0:0:0:0:0:0] + * #10 28, [ 28/ 0], [ 7 0:0 0:0:0:0:0:0] + * #11 36, [ 36/ 0], [ 9 0:0 0:0:0:0:0:0] + #12 5, [ 5/ 0], [ 1 1:0 0:0:0:0:0:0] + #13 24, [ 24/ 0], [ 6 0:0 0:0:0:0:0:0] + + There are 1 procedure descriptor entries, starting at 0. + + Procedure descriptor 0: + Name index = 10 Name = "main" + .mask 0x80000000,-4 .fmask 0x00000000,0 + .frame $29,24,$31 + Opt. start = -1 Symbols start = 1 + First line # = 3 Last line # = 6 + Line Offset = 0 Address = 0x00000000 + + There are 4 bytes holding line numbers, starting at 380. + Line 3, delta 0, count 2 + Line 4, delta 1, count 3 + Line 5, delta 1, count 2 + Line 6, delta 1, count 6 + + File #1, "/usr/include/stdio.h" + + Name index = 1 Readin = No + Merge = Yes Endian = LITTLE + Debug level = G2 Language = C + Adr = 0x00000000 + + Info Start Number Size Offset + ==== ===== ====== ==== ====== + Local strings 15 65 65 799 + Local symbols 6 10 120 508 + Line numbers 0 0 0 380 + Optimization symbols 0 0 0 0 + Procedures 1 0 0 436 + Auxiliary symbols 14 25 100 684 + Relative Files 0 0 0 0 + + There are 10 local symbols, starting at 442 + + Symbol# 0: "/usr/include/stdio.h" + End+1 symbol = 10 + String index = 1 + Storage class = Text Index = 10 + Symbol type = File Value = 0 + + Symbol# 1: "_iobuf" + End+1 symbol = 9 + String index = 22 + Storage class = Info Index = 9 + Symbol type = Block Value = 20 + + Symbol# 2: "_cnt" + Type = int + String index = 29 + Storage class = Info Index = 4 + Symbol type = Member Value = 0 + + Symbol# 3: "_ptr" + Type = ptr to char + String index = 34 + Storage class = Info Index = 15 + Symbol type = Member Value = 32 + + Symbol# 4: "_base" + Type = ptr to char + String index = 39 + Storage class = Info Index = 16 + Symbol type = Member Value = 64 + + Symbol# 5: "_bufsiz" + Type = int + String index = 45 + Storage class = Info Index = 4 + Symbol type = Member Value = 96 + + Symbol# 6: "_flag" + Type = short + String index = 53 + Storage class = Info Index = 3 + Symbol type = Member Value = 128 + + Symbol# 7: "_file" + Type = char + String index = 59 + Storage class = Info Index = 2 + Symbol type = Member Value = 144 + + Symbol# 8: "" + First symbol = 1 + String index = 0 + Storage class = Info Index = 1 + Symbol type = End Value = 0 + + Symbol# 9: "/usr/include/stdio.h" + First symbol = 0 + String index = 1 + Storage class = Text Index = 0 + Symbol type = End Value = 0 + + There are 25 auxiliary table entries, starting at 642. + + * #14 -1, [4095/1048575], [63 1:1 f:f:f:f:f:f] + #15 65544, [ 8/ 16], [ 2 0:0 1:0:0:0:0:0] + #16 65544, [ 8/ 16], [ 2 0:0 1:0:0:0:0:0] + * #17 196656, [ 48/ 48], [12 0:0 3:0:0:0:0:0] + * #18 8191, [4095/ 1], [63 1:1 0:0:0:0:f:1] + * #19 1, [ 1/ 0], [ 0 1:0 0:0:0:0:0:0] + * #20 20479, [4095/ 4], [63 1:1 0:0:0:0:f:4] + * #21 1, [ 1/ 0], [ 0 1:0 0:0:0:0:0:0] + * #22 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0] + * #23 2, [ 2/ 0], [ 0 0:1 0:0:0:0:0:0] + * #24 160, [ 160/ 0], [40 0:0 0:0:0:0:0:0] + * #25 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0] + * #26 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0] + * #27 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0] + * #28 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0] + * #29 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0] + * #30 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0] + * #31 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0] + * #32 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0] + * #33 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0] + * #34 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0] + * #35 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0] + * #36 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0] + * #37 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0] + * #38 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0] + + There are 0 procedure descriptor entries, starting at 1. + + There are 20 external symbols, starting at 1152 + + Symbol# 0: "_iob" + Type = array [3 {160}] of struct _iobuf { ifd = 1, index = 1 } + String index = 0 Ifd = 1 + Storage class = Nil Index = 17 + Symbol type = Global Value = 60 + + Symbol# 1: "fopen" + String index = 5 Ifd = 1 + Storage class = Nil Index = 1048575 + Symbol type = Proc Value = 0 + + Symbol# 2: "fdopen" + String index = 11 Ifd = 1 + Storage class = Nil Index = 1048575 + Symbol type = Proc Value = 0 + + Symbol# 3: "freopen" + String index = 18 Ifd = 1 + Storage class = Nil Index = 1048575 + Symbol type = Proc Value = 0 + + Symbol# 4: "popen" + String index = 26 Ifd = 1 + Storage class = Nil Index = 1048575 + Symbol type = Proc Value = 0 + + Symbol# 5: "tmpfile" + String index = 32 Ifd = 1 + Storage class = Nil Index = 1048575 + Symbol type = Proc Value = 0 + + Symbol# 6: "ftell" + String index = 40 Ifd = 1 + Storage class = Nil Index = 1048575 + Symbol type = Proc Value = 0 + + Symbol# 7: "rewind" + String index = 46 Ifd = 1 + Storage class = Nil Index = 1048575 + Symbol type = Proc Value = 0 + + Symbol# 8: "setbuf" + String index = 53 Ifd = 1 + Storage class = Nil Index = 1048575 + Symbol type = Proc Value = 0 + + Symbol# 9: "setbuffer" + String index = 60 Ifd = 1 + Storage class = Nil Index = 1048575 + Symbol type = Proc Value = 0 + + Symbol# 10: "setlinebuf" + String index = 70 Ifd = 1 + Storage class = Nil Index = 1048575 + Symbol type = Proc Value = 0 + + Symbol# 11: "fgets" + String index = 81 Ifd = 1 + Storage class = Nil Index = 1048575 + Symbol type = Proc Value = 0 + + Symbol# 12: "gets" + String index = 87 Ifd = 1 + Storage class = Nil Index = 1048575 + Symbol type = Proc Value = 0 + + Symbol# 13: "ctermid" + String index = 92 Ifd = 1 + Storage class = Nil Index = 1048575 + Symbol type = Proc Value = 0 + + Symbol# 14: "cuserid" + String index = 100 Ifd = 1 + Storage class = Nil Index = 1048575 + Symbol type = Proc Value = 0 + + Symbol# 15: "tempnam" + String index = 108 Ifd = 1 + Storage class = Nil Index = 1048575 + Symbol type = Proc Value = 0 + + Symbol# 16: "tmpnam" + String index = 116 Ifd = 1 + Storage class = Nil Index = 1048575 + Symbol type = Proc Value = 0 + + Symbol# 17: "sprintf" + String index = 123 Ifd = 1 + Storage class = Nil Index = 1048575 + Symbol type = Proc Value = 0 + + Symbol# 18: "main" + Type = int + String index = 131 Ifd = 0 + Storage class = Text Index = 1 + Symbol type = Proc Value = 0 + + Symbol# 19: "printf" + String index = 136 Ifd = 0 + Storage class = Undefined Index = 1048575 + Symbol type = Proc Value = 0 + + The following auxiliary table entries were unused: + + #0 0 0x00000000 void + #2 8 0x00000008 char + #3 16 0x00000010 short + #4 24 0x00000018 int + #5 32 0x00000020 long + #6 40 0x00000028 float + #7 44 0x0000002c double + #8 12 0x0000000c unsigned char + #9 20 0x00000014 unsigned short + #10 28 0x0000001c unsigned int + #11 36 0x00000024 unsigned long + #14 0 0x00000000 void + #15 24 0x00000018 int + #19 32 0x00000020 long + #20 40 0x00000028 float + #21 44 0x0000002c double + #22 12 0x0000000c unsigned char + #23 20 0x00000014 unsigned short + #24 28 0x0000001c unsigned int + #25 36 0x00000024 unsigned long + #26 48 0x00000030 struct no name { ifd = -1, index = 1048575 } + +*/ +/* Redefinition of of storage classes as an enumeration for better + debugging. */ + +typedef enum sc { + sc_Nil = scNil, /* no storage class */ + sc_Text = scText, /* text symbol */ + sc_Data = scData, /* initialized data symbol */ + sc_Bss = scBss, /* un-initialized data symbol */ + sc_Register = scRegister, /* value of symbol is register number */ + sc_Abs = scAbs, /* value of symbol is absolute */ + sc_Undefined = scUndefined, /* who knows? */ + sc_CdbLocal = scCdbLocal, /* variable's value is IN se->va.?? */ + sc_Bits = scBits, /* this is a bit field */ + sc_CdbSystem = scCdbSystem, /* value is IN CDB's address space */ + sc_RegImage = scRegImage, /* register value saved on stack */ + sc_Info = scInfo, /* symbol contains debugger information */ + sc_UserStruct = scUserStruct, /* addr in struct user for current process */ + sc_SData = scSData, /* load time only small data */ + sc_SBss = scSBss, /* load time only small common */ + sc_RData = scRData, /* load time only read only data */ + sc_Var = scVar, /* Var parameter (fortran,pascal) */ + sc_Common = scCommon, /* common variable */ + sc_SCommon = scSCommon, /* small common */ + sc_VarRegister = scVarRegister, /* Var parameter in a register */ + sc_Variant = scVariant, /* Variant record */ + sc_SUndefined = scSUndefined, /* small undefined(external) data */ + sc_Init = scInit, /* .init section symbol */ + sc_Max = scMax /* Max storage class+1 */ +} sc_t; + +/* Redefinition of symbol type. */ + +typedef enum st { + st_Nil = stNil, /* Nuthin' special */ + st_Global = stGlobal, /* external symbol */ + st_Static = stStatic, /* static */ + st_Param = stParam, /* procedure argument */ + st_Local = stLocal, /* local variable */ + st_Label = stLabel, /* label */ + st_Proc = stProc, /* " " Procedure */ + st_Block = stBlock, /* beginning of block */ + st_End = stEnd, /* end (of anything) */ + st_Member = stMember, /* member (of anything - struct/union/enum */ + st_Typedef = stTypedef, /* type definition */ + st_File = stFile, /* file name */ + st_RegReloc = stRegReloc, /* register relocation */ + st_Forward = stForward, /* forwarding address */ + st_StaticProc = stStaticProc, /* load time only static procs */ + st_Constant = stConstant, /* const */ + st_Str = stStr, /* string */ + st_Number = stNumber, /* pure number (ie. 4 NOR 2+2) */ + st_Expr = stExpr, /* 2+2 vs. 4 */ + st_Type = stType, /* post-coercion SER */ + st_Max = stMax /* max type+1 */ +} st_t; + +/* Redefinition of type qualifiers. */ + +typedef enum tq { + tq_Nil = tqNil, /* bt is what you see */ + tq_Ptr = tqPtr, /* pointer */ + tq_Proc = tqProc, /* procedure */ + tq_Array = tqArray, /* duh */ + tq_Far = tqFar, /* longer addressing - 8086/8 land */ + tq_Vol = tqVol, /* volatile */ + tq_Max = tqMax /* Max type qualifier+1 */ +} tq_t; + +/* Redefinition of basic types. */ + +typedef enum bt { + bt_Nil = btNil, /* undefined */ + bt_Adr = btAdr, /* address - integer same size as pointer */ + bt_Char = btChar, /* character */ + bt_UChar = btUChar, /* unsigned character */ + bt_Short = btShort, /* short */ + bt_UShort = btUShort, /* unsigned short */ + bt_Int = btInt, /* int */ + bt_UInt = btUInt, /* unsigned int */ + bt_Long = btLong, /* long */ + bt_ULong = btULong, /* unsigned long */ + bt_Float = btFloat, /* float (real) */ + bt_Double = btDouble, /* Double (real) */ + bt_Struct = btStruct, /* Structure (Record) */ + bt_Union = btUnion, /* Union (variant) */ + bt_Enum = btEnum, /* Enumerated */ + bt_Typedef = btTypedef, /* defined via a typedef, isymRef points */ + bt_Range = btRange, /* subrange of int */ + bt_Set = btSet, /* pascal sets */ + bt_Complex = btComplex, /* fortran complex */ + bt_DComplex = btDComplex, /* fortran double complex */ + bt_Indirect = btIndirect, /* forward or unnamed typedef */ + bt_FixedDec = btFixedDec, /* Fixed Decimal */ + bt_FloatDec = btFloatDec, /* Float Decimal */ + bt_String = btString, /* Varying Length Character String */ + bt_Bit = btBit, /* Aligned Bit String */ + bt_Picture = btPicture, /* Picture */ + bt_Void = btVoid, /* Void */ + bt_Max = btMax /* Max basic type+1 */ +} bt_t; + +#define N_TQ itqMax + +/* States for whether to hash type or not. */ +typedef enum hash_state { + hash_no = 0, /* don't hash type */ + hash_yes = 1, /* ok to hash type, or use previous hash */ + hash_record = 2 /* ok to record hash, but don't use prev. */ +} hash_state_t; + +/* Types of different sized allocation requests. */ +enum alloc_type { + alloc_type_none, /* dummy value */ + alloc_type_scope, /* nested scopes linked list */ + alloc_type_vlinks, /* glue linking pages in varray */ + alloc_type_shash, /* string hash element */ + alloc_type_thash, /* type hash element */ + alloc_type_tag, /* struct/union/tag element */ + alloc_type_forward, /* element to hold unknown tag */ + alloc_type_thead, /* head of type hash list */ + alloc_type_varray, /* general varray allocation */ + alloc_type_lineno, /* line number list */ + alloc_type_last /* last+1 element for array bounds */ +}; + +/* Types of auxiliary type information. */ +enum aux_type { + aux_tir, /* TIR type information */ + aux_rndx, /* relative index into symbol table */ + aux_dnLow, /* low dimension */ + aux_dnHigh, /* high dimension */ + aux_isym, /* symbol table index (end of proc) */ + aux_iss, /* index into string space (not used) */ + aux_width, /* width for non-default sized struc fields */ + aux_count /* count of ranges for variant arm */ +}; + +/* Structures to provide n-number of virtual arrays, each of which can + grow linearly, and which are written in the object file as + sequential pages. On systems with a BSD malloc, the + MAX_CLUSTER_PAGES should be 1 less than a power of two, since + malloc adds it's overhead, and rounds up to the next power of 2. + Pages are linked together via a linked list. + + If PAGE_SIZE is > 4096, the string length in the shash_t structure + can't be represented (assuming there are strings > 4096 bytes). */ + +#ifndef PAGE_SIZE +#define PAGE_SIZE 4096 /* size of varray pages */ +#endif + +#define PAGE_USIZE ((unsigned long) PAGE_SIZE) + + +#ifndef MAX_CLUSTER_PAGES /* # pages to get from system */ +#define MAX_CLUSTER_PAGES 63 +#endif + + +/* Linked list connecting separate page allocations. */ +typedef struct vlinks { + struct vlinks *prev; /* previous set of pages */ + struct vlinks *next; /* next set of pages */ + union page *datum; /* start of page */ + unsigned long start_index; /* starting index # of page */ +} vlinks_t; + + +/* Virtual array header. */ +typedef struct varray { + vlinks_t *first; /* first page link */ + vlinks_t *last; /* last page link */ + unsigned long num_allocated; /* # objects allocated */ + unsigned short object_size; /* size in bytes of each object */ + unsigned short objects_per_page; /* # objects that can fit on a page */ + unsigned short objects_last_page; /* # objects allocated on last page */ +} varray_t; + +#ifndef MALLOC_CHECK +#define OBJECTS_PER_PAGE(type) (PAGE_SIZE / sizeof (type)) +#else +#define OBJECTS_PER_PAGE(type) ((sizeof (type) > 1) ? 1 : PAGE_SIZE) +#endif + +#define INIT_VARRAY(type) { /* macro to initialize a varray */ \ + (vlinks_t *)0, /* first */ \ + (vlinks_t *)0, /* last */ \ + 0, /* num_allocated */ \ + sizeof (type), /* object_size */ \ + OBJECTS_PER_PAGE (type), /* objects_per_page */ \ + OBJECTS_PER_PAGE (type), /* objects_last_page */ \ +} + + +/* Master type for indexes within the symbol table. */ +typedef unsigned long symint_t; + + +/* Linked list support for nested scopes (file, block, structure, etc.). */ +typedef struct scope { + struct scope *prev; /* previous scope level */ + struct scope *free; /* free list pointer */ + struct localsym *lsym; /* pointer to local symbol node */ + st_t type; /* type of the node */ +} scope_t; + + +/* For a local symbol we store a gas symbol as well as the debugging + information we generate. The gas symbol will be NULL if this is + only a debugging symbol. */ +typedef struct localsym { + symbolS *as_sym; /* symbol as seen by gas */ + struct efdr *file_ptr; /* file pointer */ + struct ecoff_proc *proc_ptr; /* proc pointer */ + struct localsym *begin_ptr; /* symbol at start of block */ + struct ecoff_aux *index_ptr; /* index value to be filled in */ + struct forward *forward_ref; /* forward references to this symbol */ + long sym_index; /* final symbol index */ + SYMR ecoff_sym; /* ECOFF debugging symbol */ +} localsym_t; + + +/* For aux information we keep the type and the data. */ +typedef struct ecoff_aux { + enum aux_type type; /* aux type */ + AUXU data; /* aux data */ +} aux_t; + +/* For a procedure we store the gas symbol as well as the PDR + debugging information. */ +typedef struct ecoff_proc { + localsym_t *sym; /* associated symbol */ + PDR pdr; /* ECOFF debugging info */ +} proc_t; + +/* Number of proc_t structures allocated. */ +static unsigned long proc_cnt; + + +/* Forward reference list for tags referenced, but not yet defined. */ +typedef struct forward { + struct forward *next; /* next forward reference */ + struct forward *free; /* free list pointer */ + aux_t *ifd_ptr; /* pointer to store file index */ + aux_t *index_ptr; /* pointer to store symbol index */ +} forward_t; + + +/* Linked list support for tags. The first tag in the list is always + the current tag for that block. */ +typedef struct tag { + struct tag *free; /* free list pointer */ + struct shash *hash_ptr; /* pointer to the hash table head */ + struct tag *same_name; /* tag with same name in outer scope */ + struct tag *same_block; /* next tag defined in the same block. */ + struct forward *forward_ref; /* list of forward references */ + bt_t basic_type; /* bt_Struct, bt_Union, or bt_Enum */ + symint_t ifd; /* file # tag defined in */ + localsym_t *sym; /* file's local symbols */ +} tag_t; + + +/* Head of a block's linked list of tags. */ +typedef struct thead { + struct thead *prev; /* previous block */ + struct thead *free; /* free list pointer */ + struct tag *first_tag; /* first tag in block defined */ +} thead_t; + + +/* Union containing pointers to each the small structures which are freed up. */ +typedef union small_free { + scope_t *f_scope; /* scope structure */ + thead_t *f_thead; /* tag head structure */ + tag_t *f_tag; /* tag element structure */ + forward_t *f_forward; /* forward tag reference */ +} small_free_t; + + +/* String hash table entry. */ + +typedef struct shash { + char *string; /* string we are hashing */ + symint_t indx; /* index within string table */ + EXTR *esym_ptr; /* global symbol pointer */ + localsym_t *sym_ptr; /* local symbol pointer */ + localsym_t *end_ptr; /* symbol pointer to end block */ + tag_t *tag_ptr; /* tag pointer */ + proc_t *proc_ptr; /* procedure descriptor pointer */ +} shash_t; + + +/* Type hash table support. The size of the hash table must fit + within a page with the other extended file descriptor information. + Because unique types which are hashed are fewer in number than + strings, we use a smaller hash value. */ + +#define HASHBITS 30 + +#ifndef THASH_SIZE +#define THASH_SIZE 113 +#endif + +typedef struct thash { + struct thash *next; /* next hash value */ + AUXU type; /* type we are hashing */ + symint_t indx; /* index within string table */ +} thash_t; + + +/* Extended file descriptor that contains all of the support necessary + to add things to each file separately. */ +typedef struct efdr { + FDR fdr; /* File header to be written out */ + FDR *orig_fdr; /* original file header */ + char *name; /* filename */ + symint_t void_type; /* aux. pointer to 'void' type */ + symint_t int_type; /* aux. pointer to 'int' type */ + scope_t *cur_scope; /* current nested scopes */ + symint_t file_index; /* current file number */ + int nested_scopes; /* # nested scopes */ + varray_t strings; /* local strings */ + varray_t symbols; /* local symbols */ + varray_t procs; /* procedures */ + varray_t aux_syms; /* auxiliary symbols */ + struct efdr *next_file; /* next file descriptor */ + /* string/type hash tables */ + struct hash_control *str_hash; /* string hash table */ + thash_t *thash_head[THASH_SIZE]; +} efdr_t; + +/* Pre-initialized extended file structure. */ +static const efdr_t init_file = +{ + { /* FDR structure */ + 0, /* adr: memory address of beginning of file */ + 0, /* rss: file name (of source, if known) */ + 0, /* issBase: file's string space */ + 0, /* cbSs: number of bytes in the ss */ + 0, /* isymBase: beginning of symbols */ + 0, /* csym: count file's of symbols */ + 0, /* ilineBase: file's line symbols */ + 0, /* cline: count of file's line symbols */ + 0, /* ioptBase: file's optimization entries */ + 0, /* copt: count of file's optimization entries */ + 0, /* ipdFirst: start of procedures for this file */ + 0, /* cpd: count of procedures for this file */ + 0, /* iauxBase: file's auxiliary entries */ + 0, /* caux: count of file's auxiliary entries */ + 0, /* rfdBase: index into the file indirect table */ + 0, /* crfd: count file indirect entries */ + langC, /* lang: language for this file */ + 1, /* fMerge: whether this file can be merged */ + 0, /* fReadin: true if read in (not just created) */ +#ifdef TARGET_BYTES_BIG_ENDIAN + 1, /* fBigendian: if 1, compiled on big endian machine */ +#else + 0, /* fBigendian: if 1, compiled on big endian machine */ +#endif + GLEVEL_2, /* glevel: level this file was compiled with */ + 0, /* reserved: reserved for future use */ + 0, /* cbLineOffset: byte offset from header for this file ln's */ + 0, /* cbLine: size of lines for this file */ + }, + + (FDR *)0, /* orig_fdr: original file header pointer */ + (char *)0, /* name: pointer to filename */ + 0, /* void_type: ptr to aux node for void type */ + 0, /* int_type: ptr to aux node for int type */ + (scope_t *)0, /* cur_scope: current scope being processed */ + 0, /* file_index: current file # */ + 0, /* nested_scopes: # nested scopes */ + INIT_VARRAY (char), /* strings: local string varray */ + INIT_VARRAY (localsym_t), /* symbols: local symbols varray */ + INIT_VARRAY (proc_t), /* procs: procedure varray */ + INIT_VARRAY (aux_t), /* aux_syms: auxiliary symbols varray */ + + (struct efdr *)0, /* next_file: next file structure */ + + (struct hash_control *)0, /* str_hash: string hash table */ + { 0 }, /* thash_head: type hash table */ +}; + + +static efdr_t *first_file; /* first file descriptor */ +static efdr_t **last_file_ptr = &first_file; /* file descriptor tail */ + + +/* Line number information is kept in a list until the assembly is + finished. */ +typedef struct lineno_list { + struct lineno_list *next; /* next element in list */ + efdr_t *file; /* file this line is in */ + proc_t *proc; /* procedure this line is in */ + fragS *frag; /* fragment this line number is in */ + unsigned long paddr; /* offset within fragment */ + long lineno; /* actual line number */ +} lineno_list_t; + +static lineno_list_t *first_lineno; +static lineno_list_t **last_lineno_ptr = &first_lineno; + +/* Sometimes there will be some .loc statements before a .ent. We + keep them in this list so that we can fill in the procedure pointer + after we see the .ent. */ +static lineno_list_t *noproc_lineno; + +/* Union of various things that are held in pages. */ +typedef union page { + char byte [ PAGE_SIZE ]; + unsigned char ubyte [ PAGE_SIZE ]; + efdr_t file [ PAGE_SIZE / sizeof (efdr_t) ]; + FDR ofile [ PAGE_SIZE / sizeof (FDR) ]; + proc_t proc [ PAGE_SIZE / sizeof (proc_t) ]; + localsym_t sym [ PAGE_SIZE / sizeof (localsym_t) ]; + aux_t aux [ PAGE_SIZE / sizeof (aux_t) ]; + DNR dense [ PAGE_SIZE / sizeof (DNR) ]; + scope_t scope [ PAGE_SIZE / sizeof (scope_t) ]; + vlinks_t vlinks [ PAGE_SIZE / sizeof (vlinks_t) ]; + shash_t shash [ PAGE_SIZE / sizeof (shash_t) ]; + thash_t thash [ PAGE_SIZE / sizeof (thash_t) ]; + tag_t tag [ PAGE_SIZE / sizeof (tag_t) ]; + forward_t forward [ PAGE_SIZE / sizeof (forward_t) ]; + thead_t thead [ PAGE_SIZE / sizeof (thead_t) ]; + lineno_list_t lineno [ PAGE_SIZE / sizeof (lineno_list_t) ]; +} page_t; + + +/* Structure holding allocation information for small sized structures. */ +typedef struct alloc_info { + char *alloc_name; /* name of this allocation type (must be first) */ + page_t *cur_page; /* current page being allocated from */ + small_free_t free_list; /* current free list if any */ + int unallocated; /* number of elements unallocated on page */ + int total_alloc; /* total number of allocations */ + int total_free; /* total number of frees */ + int total_pages; /* total number of pages allocated */ +} alloc_info_t; + + +/* Type information collected together. */ +typedef struct type_info { + bt_t basic_type; /* basic type */ + int orig_type; /* original COFF-based type */ + int num_tq; /* # type qualifiers */ + int num_dims; /* # dimensions */ + int num_sizes; /* # sizes */ + int extra_sizes; /* # extra sizes not tied with dims */ + tag_t * tag_ptr; /* tag pointer */ + int bitfield; /* symbol is a bitfield */ + tq_t type_qualifiers[N_TQ]; /* type qualifiers (ptr, func, array)*/ + symint_t dimensions [N_TQ]; /* dimensions for each array */ + symint_t sizes [N_TQ+2]; /* sizes of each array slice + size of + struct/union/enum + bitfield size */ +} type_info_t; + +/* Pre-initialized type_info struct. */ +static const type_info_t type_info_init = { + bt_Nil, /* basic type */ + T_NULL, /* original COFF-based type */ + 0, /* # type qualifiers */ + 0, /* # dimensions */ + 0, /* # sizes */ + 0, /* sizes not tied with dims */ + NULL, /* ptr to tag */ + 0, /* bitfield */ + { /* type qualifiers */ + tq_Nil, + tq_Nil, + tq_Nil, + tq_Nil, + tq_Nil, + tq_Nil, + }, + { /* dimensions */ + 0, + 0, + 0, + 0, + 0, + 0 + }, + { /* sizes */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + }, +}; + +/* Global hash table for the tags table and global table for file + descriptors. */ + +static varray_t file_desc = INIT_VARRAY (efdr_t); + +static struct hash_control *tag_hash; + +/* Static types for int and void. Also, remember the last function's + type (which is set up when we encounter the declaration for the + function, and used when the end block for the function is emitted. */ + +static type_info_t int_type_info; +static type_info_t void_type_info; +static type_info_t last_func_type_info; +static symbolS *last_func_sym_value; + + +/* Convert COFF basic type to ECOFF basic type. The T_NULL type + really should use bt_Void, but this causes the current ecoff GDB to + issue unsupported type messages, and the Ultrix 4.00 dbx (aka MIPS + 2.0) doesn't understand it, even though the compiler generates it. + Maybe this will be fixed in 2.10 or 2.20 of the MIPS compiler + suite, but for now go with what works. + + It would make sense for the .type and .scl directives to use the + ECOFF numbers directly, rather than using the COFF numbers and + mapping them. Unfortunately, this is historically what mips-tfile + expects, and changing gcc now would be a considerable pain (the + native compiler generates debugging information internally, rather + than via the assembler, so it will never use .type or .scl). */ + +static const bt_t map_coff_types[] = { + bt_Nil, /* T_NULL */ + bt_Nil, /* T_ARG */ + bt_Char, /* T_CHAR */ + bt_Short, /* T_SHORT */ + bt_Int, /* T_INT */ + bt_Long, /* T_LONG */ + bt_Float, /* T_FLOAT */ + bt_Double, /* T_DOUBLE */ + bt_Struct, /* T_STRUCT */ + bt_Union, /* T_UNION */ + bt_Enum, /* T_ENUM */ + bt_Enum, /* T_MOE */ + bt_UChar, /* T_UCHAR */ + bt_UShort, /* T_USHORT */ + bt_UInt, /* T_UINT */ + bt_ULong /* T_ULONG */ +}; + +/* Convert COFF storage class to ECOFF storage class. */ +static const sc_t map_coff_storage[] = { + sc_Nil, /* 0: C_NULL */ + sc_Abs, /* 1: C_AUTO auto var */ + sc_Undefined, /* 2: C_EXT external */ + sc_Data, /* 3: C_STAT static */ + sc_Register, /* 4: C_REG register */ + sc_Undefined, /* 5: C_EXTDEF ??? */ + sc_Text, /* 6: C_LABEL label */ + sc_Text, /* 7: C_ULABEL user label */ + sc_Info, /* 8: C_MOS member of struct */ + sc_Abs, /* 9: C_ARG argument */ + sc_Info, /* 10: C_STRTAG struct tag */ + sc_Info, /* 11: C_MOU member of union */ + sc_Info, /* 12: C_UNTAG union tag */ + sc_Info, /* 13: C_TPDEF typedef */ + sc_Data, /* 14: C_USTATIC ??? */ + sc_Info, /* 15: C_ENTAG enum tag */ + sc_Info, /* 16: C_MOE member of enum */ + sc_Register, /* 17: C_REGPARM register parameter */ + sc_Bits, /* 18; C_FIELD bitfield */ + sc_Nil, /* 19 */ + sc_Nil, /* 20 */ + sc_Nil, /* 21 */ + sc_Nil, /* 22 */ + sc_Nil, /* 23 */ + sc_Nil, /* 24 */ + sc_Nil, /* 25 */ + sc_Nil, /* 26 */ + sc_Nil, /* 27 */ + sc_Nil, /* 28 */ + sc_Nil, /* 29 */ + sc_Nil, /* 30 */ + sc_Nil, /* 31 */ + sc_Nil, /* 32 */ + sc_Nil, /* 33 */ + sc_Nil, /* 34 */ + sc_Nil, /* 35 */ + sc_Nil, /* 36 */ + sc_Nil, /* 37 */ + sc_Nil, /* 38 */ + sc_Nil, /* 39 */ + sc_Nil, /* 40 */ + sc_Nil, /* 41 */ + sc_Nil, /* 42 */ + sc_Nil, /* 43 */ + sc_Nil, /* 44 */ + sc_Nil, /* 45 */ + sc_Nil, /* 46 */ + sc_Nil, /* 47 */ + sc_Nil, /* 48 */ + sc_Nil, /* 49 */ + sc_Nil, /* 50 */ + sc_Nil, /* 51 */ + sc_Nil, /* 52 */ + sc_Nil, /* 53 */ + sc_Nil, /* 54 */ + sc_Nil, /* 55 */ + sc_Nil, /* 56 */ + sc_Nil, /* 57 */ + sc_Nil, /* 58 */ + sc_Nil, /* 59 */ + sc_Nil, /* 60 */ + sc_Nil, /* 61 */ + sc_Nil, /* 62 */ + sc_Nil, /* 63 */ + sc_Nil, /* 64 */ + sc_Nil, /* 65 */ + sc_Nil, /* 66 */ + sc_Nil, /* 67 */ + sc_Nil, /* 68 */ + sc_Nil, /* 69 */ + sc_Nil, /* 70 */ + sc_Nil, /* 71 */ + sc_Nil, /* 72 */ + sc_Nil, /* 73 */ + sc_Nil, /* 74 */ + sc_Nil, /* 75 */ + sc_Nil, /* 76 */ + sc_Nil, /* 77 */ + sc_Nil, /* 78 */ + sc_Nil, /* 79 */ + sc_Nil, /* 80 */ + sc_Nil, /* 81 */ + sc_Nil, /* 82 */ + sc_Nil, /* 83 */ + sc_Nil, /* 84 */ + sc_Nil, /* 85 */ + sc_Nil, /* 86 */ + sc_Nil, /* 87 */ + sc_Nil, /* 88 */ + sc_Nil, /* 89 */ + sc_Nil, /* 90 */ + sc_Nil, /* 91 */ + sc_Nil, /* 92 */ + sc_Nil, /* 93 */ + sc_Nil, /* 94 */ + sc_Nil, /* 95 */ + sc_Nil, /* 96 */ + sc_Nil, /* 97 */ + sc_Nil, /* 98 */ + sc_Nil, /* 99 */ + sc_Text, /* 100: C_BLOCK block start/end */ + sc_Text, /* 101: C_FCN function start/end */ + sc_Info, /* 102: C_EOS end of struct/union/enum */ + sc_Nil, /* 103: C_FILE file start */ + sc_Nil, /* 104: C_LINE line number */ + sc_Nil, /* 105: C_ALIAS combined type info */ + sc_Nil, /* 106: C_HIDDEN ??? */ +}; + +/* Convert COFF storage class to ECOFF symbol type. */ +static const st_t map_coff_sym_type[] = { + st_Nil, /* 0: C_NULL */ + st_Local, /* 1: C_AUTO auto var */ + st_Global, /* 2: C_EXT external */ + st_Static, /* 3: C_STAT static */ + st_Local, /* 4: C_REG register */ + st_Global, /* 5: C_EXTDEF ??? */ + st_Label, /* 6: C_LABEL label */ + st_Label, /* 7: C_ULABEL user label */ + st_Member, /* 8: C_MOS member of struct */ + st_Param, /* 9: C_ARG argument */ + st_Block, /* 10: C_STRTAG struct tag */ + st_Member, /* 11: C_MOU member of union */ + st_Block, /* 12: C_UNTAG union tag */ + st_Typedef, /* 13: C_TPDEF typedef */ + st_Static, /* 14: C_USTATIC ??? */ + st_Block, /* 15: C_ENTAG enum tag */ + st_Member, /* 16: C_MOE member of enum */ + st_Param, /* 17: C_REGPARM register parameter */ + st_Member, /* 18; C_FIELD bitfield */ + st_Nil, /* 19 */ + st_Nil, /* 20 */ + st_Nil, /* 21 */ + st_Nil, /* 22 */ + st_Nil, /* 23 */ + st_Nil, /* 24 */ + st_Nil, /* 25 */ + st_Nil, /* 26 */ + st_Nil, /* 27 */ + st_Nil, /* 28 */ + st_Nil, /* 29 */ + st_Nil, /* 30 */ + st_Nil, /* 31 */ + st_Nil, /* 32 */ + st_Nil, /* 33 */ + st_Nil, /* 34 */ + st_Nil, /* 35 */ + st_Nil, /* 36 */ + st_Nil, /* 37 */ + st_Nil, /* 38 */ + st_Nil, /* 39 */ + st_Nil, /* 40 */ + st_Nil, /* 41 */ + st_Nil, /* 42 */ + st_Nil, /* 43 */ + st_Nil, /* 44 */ + st_Nil, /* 45 */ + st_Nil, /* 46 */ + st_Nil, /* 47 */ + st_Nil, /* 48 */ + st_Nil, /* 49 */ + st_Nil, /* 50 */ + st_Nil, /* 51 */ + st_Nil, /* 52 */ + st_Nil, /* 53 */ + st_Nil, /* 54 */ + st_Nil, /* 55 */ + st_Nil, /* 56 */ + st_Nil, /* 57 */ + st_Nil, /* 58 */ + st_Nil, /* 59 */ + st_Nil, /* 60 */ + st_Nil, /* 61 */ + st_Nil, /* 62 */ + st_Nil, /* 63 */ + st_Nil, /* 64 */ + st_Nil, /* 65 */ + st_Nil, /* 66 */ + st_Nil, /* 67 */ + st_Nil, /* 68 */ + st_Nil, /* 69 */ + st_Nil, /* 70 */ + st_Nil, /* 71 */ + st_Nil, /* 72 */ + st_Nil, /* 73 */ + st_Nil, /* 74 */ + st_Nil, /* 75 */ + st_Nil, /* 76 */ + st_Nil, /* 77 */ + st_Nil, /* 78 */ + st_Nil, /* 79 */ + st_Nil, /* 80 */ + st_Nil, /* 81 */ + st_Nil, /* 82 */ + st_Nil, /* 83 */ + st_Nil, /* 84 */ + st_Nil, /* 85 */ + st_Nil, /* 86 */ + st_Nil, /* 87 */ + st_Nil, /* 88 */ + st_Nil, /* 89 */ + st_Nil, /* 90 */ + st_Nil, /* 91 */ + st_Nil, /* 92 */ + st_Nil, /* 93 */ + st_Nil, /* 94 */ + st_Nil, /* 95 */ + st_Nil, /* 96 */ + st_Nil, /* 97 */ + st_Nil, /* 98 */ + st_Nil, /* 99 */ + st_Block, /* 100: C_BLOCK block start/end */ + st_Proc, /* 101: C_FCN function start/end */ + st_End, /* 102: C_EOS end of struct/union/enum */ + st_File, /* 103: C_FILE file start */ + st_Nil, /* 104: C_LINE line number */ + st_Nil, /* 105: C_ALIAS combined type info */ + st_Nil, /* 106: C_HIDDEN ??? */ +}; + + +/* Keep track of different sized allocation requests. */ +static alloc_info_t alloc_counts[ (int)alloc_type_last ]; + +/* Various statics. */ +static efdr_t *cur_file_ptr = (efdr_t *) 0; /* current file desc. header */ +static proc_t *cur_proc_ptr = (proc_t *) 0; /* current procedure header */ +static thead_t *cur_tag_head = (thead_t *)0; /* current tag head */ +#ifdef ECOFF_DEBUG +static int debug = 0; /* trace functions */ +#endif +static int stabs_seen = 0; /* != 0 if stabs have been seen */ + + +/* Pseudo symbol to use when putting stabs into the symbol table. */ +#ifndef STABS_SYMBOL +#define STABS_SYMBOL "@stabs" +#endif + +static char stabs_symbol[] = STABS_SYMBOL; + +/* Prototypes for functions defined in this file. */ + +static void add_varray_page PARAMS ((varray_t *vp)); +static symint_t add_string PARAMS ((varray_t *vp, + struct hash_control *hash_tbl, + const char *str, + shash_t **ret_hash)); +static localsym_t *add_ecoff_symbol PARAMS ((const char *str, st_t type, + sc_t storage, symbolS *sym, + symint_t value, + symint_t indx)); +static symint_t add_aux_sym_symint PARAMS ((symint_t aux_word)); +static symint_t add_aux_sym_rndx PARAMS ((int file_index, + symint_t sym_index)); +static symint_t add_aux_sym_tir PARAMS ((type_info_t *t, + hash_state_t state, + thash_t **hash_tbl)); +static tag_t *get_tag PARAMS ((const char *tag, localsym_t *sym, + bt_t basic_type)); +static void add_unknown_tag PARAMS ((tag_t *ptag)); +static void add_procedure PARAMS ((char *func)); +static void add_file PARAMS ((const char *file_name, int indx)); +#ifdef ECOFF_DEBUG +static char *sc_to_string PARAMS ((sc_t storage_class)); +static char *st_to_string PARAMS ((st_t symbol_type)); +#endif +static void obj_ecoff_def PARAMS ((int)); +static void obj_ecoff_dim PARAMS ((int)); +static void obj_ecoff_endef PARAMS ((int)); +static void obj_ecoff_file PARAMS ((int)); +static void obj_ecoff_scl PARAMS ((int)); +static void obj_ecoff_size PARAMS ((int)); +static void obj_ecoff_tag PARAMS ((int)); +static void obj_ecoff_type PARAMS ((int)); +static void obj_ecoff_val PARAMS ((int)); +static void obj_ecoff_stab PARAMS ((int)); +static void obj_ecoff_ent PARAMS ((int)); +static void obj_ecoff_begin PARAMS ((int)); +static void obj_ecoff_bend PARAMS ((int)); +static void obj_ecoff_end PARAMS ((int)); +static void obj_ecoff_fmask PARAMS ((int)); +static void obj_ecoff_frame PARAMS ((int)); +static void obj_ecoff_loc PARAMS ((int)); +static void obj_ecoff_mask PARAMS ((int)); +static void mark_stabs PARAMS ((int)); +static char *ecoff_add_bytes PARAMS ((char **buf, char **bufend, + char *bufptr, long need)); +static long ecoff_longword_adjust PARAMS ((char **buf, char **bufend, + long offset, char **bufptrptr)); +static long ecoff_build_lineno PARAMS ((char **buf, char **bufend, + long offset, long *linecntptr)); +static long ecoff_build_symbols PARAMS ((char **buf, char **bufend, + long offset, + char **extbuf, char **extbufend, + long *extoffset, + varray_t *ext_strings, + struct hash_control *ext_str_hash)); +static long ecoff_build_procs PARAMS ((char **buf, char **bufend, + long offset)); +static long ecoff_build_aux PARAMS ((char **buf, char **bufend, + long offset)); +static long ecoff_build_strings PARAMS ((char **buf, char **bufend, + long offset, + varray_t *vp)); +static long ecoff_build_ss PARAMS ((char **buf, char **bufend, + long offset)); +static long ecoff_build_fdr PARAMS ((char **buf, char **bufend, + long offset)); +static void ecoff_set_vma PARAMS ((void)); +static page_t *allocate_cluster PARAMS ((unsigned long npages)); +static page_t *allocate_page PARAMS ((void)); +static scope_t *allocate_scope PARAMS ((void)); +static void free_scope PARAMS ((scope_t *ptr)); +static vlinks_t *allocate_vlinks PARAMS ((void)); +static shash_t *allocate_shash PARAMS ((void)); +static thash_t *allocate_thash PARAMS ((void)); +static tag_t *allocate_tag PARAMS ((void)); +static void free_tag PARAMS ((tag_t *ptr)); +static forward_t *allocate_forward PARAMS ((void)); +static thead_t *allocate_thead PARAMS ((void)); +static void free_thead PARAMS ((thead_t *ptr)); +static lineno_list_t *allocate_lineno_list PARAMS ((void)); + +/* Why isn't this in some header file somewhere? In fact, is it even + necessary? */ +#define SKIP_WHITESPACES() \ + do \ + { \ + while (*input_line_pointer == ' ' \ + || *input_line_pointer == '\t') \ + ++input_line_pointer; \ + } \ + while (0) + +/* These are the pseudo-ops we support in this file. Only those + relating to debugging information are supported here. + + The following pseudo-ops from the Kane and Heinrich MIPS book + should be defined here, but are currently unsupported: .aent, + .bgnb, .endb, .verstamp, .vreg. + + The following pseudo-ops from the Kane and Heinrich MIPS book are + MIPS CPU specific, and should be defined by tc-mips.c: .alias, + .extern, .galive, .gjaldef, .gjrlive, .livereg, .noalias, .option, + .rdata, .sdata, .set. + + The following pseudo-ops from the Kane and Heinrich MIPS book are + not MIPS CPU specific, but are also not ECOFF specific. I have + only listed the ones which are not already in read.c. It's not + completely clear where these should be defined, but tc-mips.c is + probably the most reasonable place: .asciiz, .asm0, .endr, .err, + .half, .lab, .repeat, .struct, .weakext. */ + +const pseudo_typeS obj_pseudo_table[] = +{ + /* COFF style debugging information. .ln is not used; .loc is used + instead. */ + { "def", obj_ecoff_def, 0 }, + { "dim", obj_ecoff_dim, 0 }, + { "endef", obj_ecoff_endef, 0 }, + { "file", obj_ecoff_file, 0 }, + { "scl", obj_ecoff_scl, 0 }, + { "size", obj_ecoff_size, 0 }, + { "tag", obj_ecoff_tag, 0 }, + { "type", obj_ecoff_type, 0 }, + { "val", obj_ecoff_val, 0 }, + + /* stabs debugging information. */ + { "stabd", obj_ecoff_stab, 'd' }, + { "stabn", obj_ecoff_stab, 'n' }, + { "stabs", obj_ecoff_stab, 's' }, + + /* ECOFF specific debugging information. */ + { "begin", obj_ecoff_begin, 0 }, + { "bend", obj_ecoff_bend, 0 }, + { "end", obj_ecoff_end, 0 }, + { "ent", obj_ecoff_ent, 0 }, + { "fmask", obj_ecoff_fmask, 0 }, + { "frame", obj_ecoff_frame, 0 }, + { "loc", obj_ecoff_loc, 0 }, + { "mask", obj_ecoff_mask, 0 }, + + /* Sentinel. */ + { NULL } +}; + +/* This function is called when the assembler starts up. */ + +void +obj_read_begin_hook () +{ + tag_hash = hash_new (); + if (tag_hash == (struct hash_control *) NULL) + as_fatal ("Can't create hash table"); +} + +/* This function is called when a symbol is created. */ + +void +obj_symbol_new_hook (symbolP) + symbolS *symbolP; +{ + symbolP->ecoff_file = cur_file_ptr; + symbolP->ecoff_symbol = 0; +} + +/* Add a page to a varray object. */ + +static void +add_varray_page (vp) + varray_t *vp; /* varray to add page to */ +{ + vlinks_t *new_links = allocate_vlinks (); + +#ifdef MALLOC_CHECK + if (vp->object_size > 1) + new_links->datum = (page_t *) xcalloc (1, vp->object_size); + else +#endif + new_links->datum = allocate_page (); + + alloc_counts[(int)alloc_type_varray].total_alloc++; + alloc_counts[(int)alloc_type_varray].total_pages++; + + new_links->start_index = vp->num_allocated; + vp->objects_last_page = 0; + + if (vp->first == (vlinks_t *) NULL) /* first allocation? */ + vp->first = vp->last = new_links; + else + { /* 2nd or greater allocation */ + new_links->prev = vp->last; + vp->last->next = new_links; + vp->last = new_links; + } +} + +/* Add a string (and null pad) to one of the string tables. */ + +static symint_t +add_string (vp, hash_tbl, str, ret_hash) + varray_t *vp; /* string obstack */ + struct hash_control *hash_tbl; /* ptr to hash table */ + const char *str; /* string */ + shash_t **ret_hash; /* return hash pointer */ +{ + register unsigned int len = strlen (str); + register shash_t *hash_ptr; + + if (len >= PAGE_USIZE) + as_fatal ("String too big (%lu bytes)", len); + + hash_ptr = (shash_t *) hash_find (hash_tbl, str); + if (hash_ptr == (shash_t *) NULL) + { + register char *err; + + if (vp->objects_last_page + len >= PAGE_USIZE) + { + vp->num_allocated = + ((vp->num_allocated + PAGE_USIZE - 1) / PAGE_USIZE) * PAGE_USIZE; + add_varray_page (vp); + } + + hash_ptr = allocate_shash (); + hash_ptr->indx = vp->num_allocated; + + hash_ptr->string = &vp->last->datum->byte[vp->objects_last_page]; + + vp->objects_last_page += len + 1; + vp->num_allocated += len + 1; + + strcpy (hash_ptr->string, str); + + err = hash_insert (hash_tbl, str, (char *) hash_ptr); + if (*err != '\0') + as_fatal ("Inserting \"%s\" into string hash table: %s", + str, err); + } + + if (ret_hash != (shash_t **) NULL) + *ret_hash = hash_ptr; + + return hash_ptr->indx; +} + +/* Add debugging information for a symbol. */ + +static localsym_t * +add_ecoff_symbol (str, type, storage, sym_value, value, indx) + const char *str; /* symbol name */ + st_t type; /* symbol type */ + sc_t storage; /* storage class */ + symbolS *sym_value; /* associated symbol. */ + symint_t value; /* value of symbol */ + symint_t indx; /* index to local/aux. syms */ +{ + localsym_t *psym; + register scope_t *pscope; + register thead_t *ptag_head; + register tag_t *ptag; + register tag_t *ptag_next; + register varray_t *vp = &cur_file_ptr->symbols; + register int scope_delta = 0; + shash_t *hash_ptr = (shash_t *) NULL; + + if (cur_file_ptr == (efdr_t *) NULL) + as_fatal ("no current file pointer"); + + vp = &cur_file_ptr->symbols; + + if (vp->objects_last_page == vp->objects_per_page) + add_varray_page (vp); + + psym = &vp->last->datum->sym[ vp->objects_last_page++ ]; + + psym->as_sym = sym_value; + if (sym_value != (symbolS *) NULL) + sym_value->ecoff_symbol = 1; + psym->file_ptr = cur_file_ptr; + psym->proc_ptr = cur_proc_ptr; + psym->begin_ptr = (localsym_t *) NULL; + psym->index_ptr = (aux_t *) NULL; + psym->forward_ref = (forward_t *) NULL; + psym->sym_index = -1; + psym->ecoff_sym.value = value; + psym->ecoff_sym.st = (unsigned) type; + psym->ecoff_sym.sc = (unsigned) storage; + psym->ecoff_sym.index = indx; + + /* If there is an associated symbol, we wait until the end of the + assembly before deciding where to put the name (it may be just an + external symbol). Otherwise, this is just a debugging symbol and + the name should go with the current file. */ + if (sym_value == (symbolS *) NULL) + psym->ecoff_sym.iss = ((str == (const char *) NULL) + ? 0 + : add_string (&cur_file_ptr->strings, + cur_file_ptr->str_hash, + str, + &hash_ptr)); + + ++vp->num_allocated; + + if (MIPS_IS_STAB (&psym->ecoff_sym)) + return psym; + + /* Save the symbol within the hash table if this is a static + item, and it has a name. */ + if (hash_ptr != (shash_t *) NULL + && (type == st_Global || type == st_Static || type == st_Label + || type == st_Proc || type == st_StaticProc)) + hash_ptr->sym_ptr = psym; + + /* push or pop a scope if appropriate. */ + switch (type) + { + default: + break; + + case st_File: /* beginning of file */ + case st_Proc: /* procedure */ + case st_StaticProc: /* static procedure */ + case st_Block: /* begin scope */ + pscope = allocate_scope (); + pscope->prev = cur_file_ptr->cur_scope; + pscope->lsym = psym; + pscope->type = type; + cur_file_ptr->cur_scope = pscope; + + if (type != st_File) + scope_delta = 1; + + /* For every block type except file, struct, union, or + enumeration blocks, push a level on the tag stack. We omit + file types, so that tags can span file boundaries. */ + if (type != st_File && storage != sc_Info) + { + ptag_head = allocate_thead (); + ptag_head->first_tag = 0; + ptag_head->prev = cur_tag_head; + cur_tag_head = ptag_head; + } + break; + + case st_End: + pscope = cur_file_ptr->cur_scope; + if (pscope == (scope_t *) NULL) + as_fatal ("too many st_End's"); + else + { + st_t begin_type = (st_t) pscope->lsym->ecoff_sym.st; + + psym->begin_ptr = pscope->lsym; + + if (begin_type != st_File) + scope_delta = -1; + + /* Except for file, structure, union, or enumeration end + blocks remove all tags created within this scope. */ + if (begin_type != st_File && storage != sc_Info) + { + ptag_head = cur_tag_head; + cur_tag_head = ptag_head->prev; + + for (ptag = ptag_head->first_tag; + ptag != (tag_t *) NULL; + ptag = ptag_next) + { + if (ptag->forward_ref != (forward_t *) NULL) + add_unknown_tag (ptag); + + ptag_next = ptag->same_block; + ptag->hash_ptr->tag_ptr = ptag->same_name; + free_tag (ptag); + } + + free_thead (ptag_head); + } + + cur_file_ptr->cur_scope = pscope->prev; + + /* block begin gets next sym #. This is set when we know + the symbol index value. */ + + /* Functions push two or more aux words as follows: + 1st word: index+1 of the end symbol (filled in later). + 2nd word: type of the function (plus any aux words needed). + Also, tie the external pointer back to the function begin symbol. */ + if (begin_type != st_File && begin_type != st_Block) + { + symint_t type; + varray_t *vp = &cur_file_ptr->aux_syms; + + pscope->lsym->ecoff_sym.index = add_aux_sym_symint (0); + pscope->lsym->index_ptr = + &vp->last->datum->aux[vp->objects_last_page - 1]; + type = add_aux_sym_tir (&last_func_type_info, + hash_no, + &cur_file_ptr->thash_head[0]); +/* + if (last_func_sym_value != (symbolS *) NULL) + { + last_func_sym_value->ifd = cur_file_ptr->file_index; + last_func_sym_value->index = type; + } + */ + } + + free_scope (pscope); + } + } + + cur_file_ptr->nested_scopes += scope_delta; + +#ifdef ECOFF_DEBUG + if (debug && type != st_File + && (debug > 2 || type == st_Block || type == st_End + || type == st_Proc || type == st_StaticProc)) + { + char *sc_str = sc_to_string (storage); + char *st_str = st_to_string (type); + int depth = cur_file_ptr->nested_scopes + (scope_delta < 0); + + fprintf (stderr, + "\tlsym\tv= %10ld, depth= %2d, sc= %-12s", + value, depth, sc_str); + + if (str_start && str_end_p1 - str_start > 0) + fprintf (stderr, " st= %-11s name= %.*s\n", st_str, str_end_p1 - str_start, str_start); + else + { + unsigned long len = strlen (st_str); + fprintf (stderr, " st= %.*s\n", len-1, st_str); + } + } +#endif + + return psym; +} + +/* Add an auxiliary symbol (passing a symint). This is actually used + for integral aux types, not just symints. */ + +static symint_t +add_aux_sym_symint (aux_word) + symint_t aux_word; /* auxiliary information word */ +{ + register varray_t *vp; + register aux_t *aux_ptr; + + if (cur_file_ptr == (efdr_t *) NULL) + as_fatal ("no current file pointer"); + + vp = &cur_file_ptr->aux_syms; + + if (vp->objects_last_page == vp->objects_per_page) + add_varray_page (vp); + + aux_ptr = &vp->last->datum->aux[vp->objects_last_page++]; + aux_ptr->type = aux_isym; + aux_ptr->data.isym = aux_word; + + return vp->num_allocated++; +} + + +/* Add an auxiliary symbol (passing a file/symbol index combo). */ + +static symint_t +add_aux_sym_rndx (file_index, sym_index) + int file_index; + symint_t sym_index; +{ + register varray_t *vp; + register aux_t *aux_ptr; + + if (cur_file_ptr == (efdr_t *) NULL) + as_fatal ("no current file pointer"); + + vp = &cur_file_ptr->aux_syms; + + if (vp->objects_last_page == vp->objects_per_page) + add_varray_page (vp); + + aux_ptr = &vp->last->datum->aux[vp->objects_last_page++]; + aux_ptr->type = aux_rndx; + aux_ptr->data.rndx.rfd = file_index; + aux_ptr->data.rndx.index = sym_index; + + return vp->num_allocated++; +} + +/* Add an auxiliary symbol (passing the basic type and possibly + type qualifiers). */ + +static symint_t +add_aux_sym_tir (t, state, hash_tbl) + type_info_t *t; /* current type information */ + hash_state_t state; /* whether to hash type or not */ + thash_t **hash_tbl; /* pointer to hash table to use */ +{ + register varray_t *vp; + register aux_t *aux_ptr; + static AUXU init_aux; + symint_t ret; + int i; + AUXU aux; + + if (cur_file_ptr == (efdr_t *) NULL) + as_fatal ("no current file pointer"); + + vp = &cur_file_ptr->aux_syms; + + aux = init_aux; + aux.ti.bt = (int) t->basic_type; + aux.ti.continued = 0; + aux.ti.fBitfield = t->bitfield; + + aux.ti.tq0 = (int) t->type_qualifiers[0]; + aux.ti.tq1 = (int) t->type_qualifiers[1]; + aux.ti.tq2 = (int) t->type_qualifiers[2]; + aux.ti.tq3 = (int) t->type_qualifiers[3]; + aux.ti.tq4 = (int) t->type_qualifiers[4]; + aux.ti.tq5 = (int) t->type_qualifiers[5]; + + + /* For anything that adds additional information, we must not hash, + so check here, and reset our state. */ + + if (state != hash_no + && (t->type_qualifiers[0] == tq_Array + || t->type_qualifiers[1] == tq_Array + || t->type_qualifiers[2] == tq_Array + || t->type_qualifiers[3] == tq_Array + || t->type_qualifiers[4] == tq_Array + || t->type_qualifiers[5] == tq_Array + || t->basic_type == bt_Struct + || t->basic_type == bt_Union + || t->basic_type == bt_Enum + || t->bitfield + || t->num_dims > 0)) + state = hash_no; + + /* See if we can hash this type, and save some space, but some types + can't be hashed (because they contain arrays or continuations), + and others can be put into the hash list, but cannot use existing + types because other aux entries precede this one. */ + + if (state != hash_no) + { + register thash_t *hash_ptr; + register symint_t hi; + + hi = aux.isym & ((1 << HASHBITS) - 1); + hi %= THASH_SIZE; + + for (hash_ptr = hash_tbl[hi]; + hash_ptr != (thash_t *)0; + hash_ptr = hash_ptr->next) + { + if (aux.isym == hash_ptr->type.isym) + break; + } + + if (hash_ptr != (thash_t *) NULL && state == hash_yes) + return hash_ptr->indx; + + if (hash_ptr == (thash_t *) NULL) + { + hash_ptr = allocate_thash (); + hash_ptr->next = hash_tbl[hi]; + hash_ptr->type = aux; + hash_ptr->indx = vp->num_allocated; + hash_tbl[hi] = hash_ptr; + } + } + + /* Everything is set up, add the aux symbol. */ + if (vp->objects_last_page == vp->objects_per_page) + add_varray_page (vp); + + aux_ptr = &vp->last->datum->aux[ vp->objects_last_page++ ]; + aux_ptr->type = aux_tir; + aux_ptr->data = aux; + + ret = vp->num_allocated++; + + /* Add bitfield length if it exists. + + NOTE: Mips documentation claims bitfield goes at the end of the + AUX record, but the DECstation compiler emits it here. + (This would only make a difference for enum bitfields.) + + Also note: We use the last size given since gcc may emit 2 + for an enum bitfield. */ + + if (t->bitfield) + (void) add_aux_sym_symint ((symint_t)t->sizes[t->num_sizes-1]); + + + /* Add tag information if needed. Structure, union, and enum + references add 2 aux symbols: a [file index, symbol index] + pointer to the structure type, and the current file index. */ + + if (t->basic_type == bt_Struct + || t->basic_type == bt_Union + || t->basic_type == bt_Enum) + { + register symint_t file_index = t->tag_ptr->ifd; + register localsym_t *sym = t->tag_ptr->sym; + register forward_t *forward_ref = allocate_forward (); + + if (sym != (localsym_t *) NULL) + { + forward_ref->next = sym->forward_ref; + sym->forward_ref = forward_ref; + } + else + { + forward_ref->next = t->tag_ptr->forward_ref; + t->tag_ptr->forward_ref = forward_ref; + } + + (void) add_aux_sym_rndx (ST_RFDESCAPE, indexNil); + forward_ref->index_ptr + = &vp->last->datum->aux[ vp->objects_last_page - 1]; + + (void) add_aux_sym_symint (file_index); + forward_ref->ifd_ptr + = &vp->last->datum->aux[ vp->objects_last_page - 1]; + } + + /* Add information about array bounds if they exist. */ + for (i = 0; i < t->num_dims; i++) + { + (void) add_aux_sym_rndx (ST_RFDESCAPE, + cur_file_ptr->int_type); + + (void) add_aux_sym_symint (cur_file_ptr->file_index); /* file index*/ + (void) add_aux_sym_symint ((symint_t) 0); /* low bound */ + (void) add_aux_sym_symint (t->dimensions[i] - 1); /* high bound*/ + (void) add_aux_sym_symint ((t->dimensions[i] == 0) /* stride */ + ? 0 + : (t->sizes[i] * 8) / t->dimensions[i]); + }; + + /* NOTE: Mips documentation claims that the bitfield width goes here. + But it needs to be emitted earlier. */ + + return ret; +} + +/* Add a tag to the tag table (unless it already exists). */ + +static tag_t * +get_tag (tag, sym, basic_type) + const char *tag; /* tag name */ + localsym_t *sym; /* tag start block */ + bt_t basic_type; /* bt_Struct, bt_Union, or bt_Enum */ +{ + shash_t *hash_ptr; + char *err; + tag_t *tag_ptr; + + if (cur_file_ptr == (efdr_t *) NULL) + as_fatal ("no current file pointer"); + + hash_ptr = (shash_t *) hash_find (tag_hash, tag); + + if (hash_ptr != (shash_t *) NULL + && hash_ptr->tag_ptr != (tag_t *) NULL) + { + tag_ptr = hash_ptr->tag_ptr; + if (sym != (localsym_t *) NULL) + { + tag_ptr->basic_type = basic_type; + tag_ptr->ifd = cur_file_ptr->file_index; + tag_ptr->sym = sym; + } + return tag_ptr; + } + + if (hash_ptr == (shash_t *) NULL) + { + hash_ptr = allocate_shash (); + err = hash_insert (tag_hash, tag, (char *) hash_ptr); + if (*err != '\0') + as_fatal ("Inserting \"%s\" into tag hash table: %s", + tag, err); + } + + tag_ptr = allocate_tag (); + tag_ptr->forward_ref = (forward_t *) NULL; + tag_ptr->hash_ptr = hash_ptr; + tag_ptr->same_name = hash_ptr->tag_ptr; + tag_ptr->basic_type = basic_type; + tag_ptr->sym = sym; + tag_ptr->ifd = ((sym == (localsym_t *) NULL) + ? -1 + : cur_file_ptr->file_index); + tag_ptr->same_block = cur_tag_head->first_tag; + + cur_tag_head->first_tag = tag_ptr; + hash_ptr->tag_ptr = tag_ptr; + + return tag_ptr; +} + +/* Add an unknown {struct, union, enum} tag. */ + +static void +add_unknown_tag (ptag) + tag_t *ptag; /* pointer to tag information */ +{ + shash_t *hash_ptr = ptag->hash_ptr; + char *name = hash_ptr->string; + localsym_t *sym; + forward_t **pf; + +#ifdef ECOFF_DEBUG + if (debug > 1) + { + char *agg_type = "{unknown aggregate type}"; + switch (ptag->basic_type) + { + case bt_Struct: agg_type = "struct"; break; + case bt_Union: agg_type = "union"; break; + case bt_Enum: agg_type = "enum"; break; + default: break; + } + + fprintf (stderr, "unknown %s %.*s found\n", agg_type, + hash_ptr->len, name_start); + } +#endif + + sym = add_ecoff_symbol (name, + st_Block, + sc_Info, + (symbolS *) NULL, + (symint_t) 0, + (symint_t) 0); + + (void) add_ecoff_symbol (name, + st_End, + sc_Info, + (symbolS *) NULL, + (symint_t) 0, + (symint_t) 0); + + for (pf = &sym->forward_ref; *pf != (forward_t *) NULL; pf = &(*pf)->next) + ; + *pf = ptag->forward_ref; +} + +/* Add a procedure to the current file's list of procedures, and record + this is the current procedure. */ + +static void +add_procedure (func) + char *func; /* func name */ +{ + register varray_t *vp; + register proc_t *new_proc_ptr; + +#ifdef ECOFF_DEBUG + if (debug) + fputc ('\n', stderr); +#endif + + if (cur_file_ptr == (efdr_t *) NULL) + as_fatal ("no current file pointer"); + + vp = &cur_file_ptr->procs; + + if (vp->objects_last_page == vp->objects_per_page) + add_varray_page (vp); + + cur_proc_ptr = new_proc_ptr = &vp->last->datum->proc[vp->objects_last_page++]; + + vp->num_allocated++; + + new_proc_ptr->pdr.isym = -1; + new_proc_ptr->pdr.iline = -1; + + /* Push the start of the function. */ + new_proc_ptr->sym = add_ecoff_symbol (func, st_Proc, sc_Text, + symbol_find_or_make (func), + (symint_t) 0, (symint_t) 0); + + ++proc_cnt; + + /* Fill in the linenos preceding the .ent, if any. */ + if (noproc_lineno != (lineno_list_t *) NULL) + { + lineno_list_t *l; + + for (l = noproc_lineno; l != (lineno_list_t *) NULL; l = l->next) + l->proc = new_proc_ptr; + *last_lineno_ptr = noproc_lineno; + while (*last_lineno_ptr != NULL) + last_lineno_ptr = &(*last_lineno_ptr)->next; + noproc_lineno = (lineno_list_t *) NULL; + } +} + +/* Add a new filename, and set up all of the file relative + virtual arrays (strings, symbols, aux syms, etc.). Record + where the current file structure lives. */ + +static void +add_file (file_name, indx) + const char *file_name; /* file name */ + int indx; +{ + register int first_ch; + register efdr_t *fil_ptr; + +#ifdef ECOFF_DEBUG + if (debug) + fprintf (stderr, "\tfile\t%.*s\n", len, file_start); +#endif + + /* If the file name is NULL, then no .file symbol appeared, and we + want to use the actual file name. Unfortunately, we don't have a + clean way to access it. */ + if (file_name == (const char *) NULL) + { + extern char *logical_input_file; + extern char *physical_input_file; + + if (first_file != (efdr_t *) NULL) + as_fatal ("fake .file after real one"); + file_name = logical_input_file; + if (file_name == (const char *) NULL) + { + file_name = physical_input_file; + if (file_name == (const char *) NULL) + file_name = "UNKNOWN"; + } + } + + first_ch = *file_name; + + /* See if the file has already been created. */ + for (fil_ptr = first_file; + fil_ptr != (efdr_t *) NULL; + fil_ptr = fil_ptr->next_file) + { + if (first_ch == fil_ptr->name[0] + && strcmp (file_name, fil_ptr->name) == 0) + { + cur_file_ptr = fil_ptr; + break; + } + } + + /* If this is a new file, create it. */ + if (fil_ptr == (efdr_t *) NULL) + { + if (file_desc.objects_last_page == file_desc.objects_per_page) + add_varray_page (&file_desc); + + fil_ptr = cur_file_ptr = + &file_desc.last->datum->file[file_desc.objects_last_page++]; + *fil_ptr = init_file; + + fil_ptr->file_index = indx; + ++file_desc.num_allocated; + + /* Allocate the string hash table. */ + fil_ptr->str_hash = hash_new (); + if (fil_ptr->str_hash == (struct hash_control *) NULL) + as_fatal ("Can't create hash table"); + + /* Make sure 0 byte in string table is null */ + add_string (&fil_ptr->strings, + fil_ptr->str_hash, + "", + (shash_t **)0); + + if (strlen (file_name) > PAGE_USIZE - 2) + as_fatal ("Filename goes over one page boundary."); + + /* Push the start of the filename. We assume that the filename + will be stored at string offset 1. */ + (void) add_ecoff_symbol (file_name, st_File, sc_Text, + (symbolS *) NULL, + (symint_t) 0, (symint_t) 0); + fil_ptr->fdr.rss = 1; + fil_ptr->name = &fil_ptr->strings.last->datum->byte[1]; + + /* Update the linked list of file descriptors. */ + *last_file_ptr = fil_ptr; + last_file_ptr = &fil_ptr->next_file; + + /* Add void & int types to the file (void should be first to catch + errant 0's within the index fields). */ + fil_ptr->void_type = add_aux_sym_tir (&void_type_info, + hash_yes, + &cur_file_ptr->thash_head[0]); + + fil_ptr->int_type = add_aux_sym_tir (&int_type_info, + hash_yes, + &cur_file_ptr->thash_head[0]); + } +} + +#ifdef ECOFF_DEBUG + +/* Convert storage class to string. */ + +static char * +sc_to_string(storage_class) + sc_t storage_class; +{ + switch(storage_class) + { + case sc_Nil: return "Nil,"; + case sc_Text: return "Text,"; + case sc_Data: return "Data,"; + case sc_Bss: return "Bss,"; + case sc_Register: return "Register,"; + case sc_Abs: return "Abs,"; + case sc_Undefined: return "Undefined,"; + case sc_CdbLocal: return "CdbLocal,"; + case sc_Bits: return "Bits,"; + case sc_CdbSystem: return "CdbSystem,"; + case sc_RegImage: return "RegImage,"; + case sc_Info: return "Info,"; + case sc_UserStruct: return "UserStruct,"; + case sc_SData: return "SData,"; + case sc_SBss: return "SBss,"; + case sc_RData: return "RData,"; + case sc_Var: return "Var,"; + case sc_Common: return "Common,"; + case sc_SCommon: return "SCommon,"; + case sc_VarRegister: return "VarRegister,"; + case sc_Variant: return "Variant,"; + case sc_SUndefined: return "SUndefined,"; + case sc_Init: return "Init,"; + case sc_Max: return "Max,"; + } + + return "???,"; +} + +#endif /* DEBUG */ + +#ifdef ECOFF_DEBUG + +/* Convert symbol type to string. */ + +static char * +st_to_string(symbol_type) + st_t symbol_type; +{ + switch(symbol_type) + { + case st_Nil: return "Nil,"; + case st_Global: return "Global,"; + case st_Static: return "Static,"; + case st_Param: return "Param,"; + case st_Local: return "Local,"; + case st_Label: return "Label,"; + case st_Proc: return "Proc,"; + case st_Block: return "Block,"; + case st_End: return "End,"; + case st_Member: return "Member,"; + case st_Typedef: return "Typedef,"; + case st_File: return "File,"; + case st_RegReloc: return "RegReloc,"; + case st_Forward: return "Forward,"; + case st_StaticProc: return "StaticProc,"; + case st_Constant: return "Constant,"; + case st_Str: return "String,"; + case st_Number: return "Number,"; + case st_Expr: return "Expr,"; + case st_Type: return "Type,"; + case st_Max: return "Max,"; + } + + return "???,"; +} + +#endif /* DEBUG */ + +/* Parse .begin directives which have a label as the first argument + which gives the location of the start of the block. */ + +static void +obj_ecoff_begin (ignore) + int ignore; +{ + char *name; + char name_end; + + if (cur_file_ptr == (efdr_t *) NULL) + { + as_warn (".begin directive without a preceding .file directive"); + demand_empty_rest_of_line (); + return; + } + + if (cur_proc_ptr == (proc_t *) NULL) + { + as_warn (".begin directive without a preceding .ent directive"); + demand_empty_rest_of_line (); + return; + } + + name = input_line_pointer; + name_end = get_symbol_end (); + + (void) add_ecoff_symbol ((const char *) NULL, st_Block, sc_Text, + symbol_find_or_make (name), + (symint_t) 0, (symint_t) 0); + + *input_line_pointer = name_end; + + demand_empty_rest_of_line (); +} + +/* Parse .bend directives which have a label as the first argument + which gives the location of the end of the block. */ + +static void +obj_ecoff_bend (ignore) + int ignore; +{ + char *name; + char name_end; + symbolS *begin; + + if (cur_file_ptr == (efdr_t *) NULL) + { + as_warn (".bend directive without a preceding .file directive"); + demand_empty_rest_of_line (); + return; + } + + if (cur_proc_ptr == (proc_t *) NULL) + { + as_warn (".bend directive without a preceding .ent directive"); + demand_empty_rest_of_line (); + return; + } + + name = input_line_pointer; + name_end = get_symbol_end (); + + /* The value is the distance between the .bend directive and the + corresponding symbol. We create a fake symbol to hold the + current location, and put in the offset when we write out the + symbol. */ + begin = symbol_find (name); + if (begin == (symbolS *) NULL) + as_warn (".bend directive names unknown symbol"); + else + (void) add_ecoff_symbol (name, st_End, sc_Text, + symbol_new ("L0\001", now_seg, + frag_now_fix (), frag_now), + (symint_t) 0, (symint_t) 0); + + *input_line_pointer = name_end; + + demand_empty_rest_of_line (); +} + +/* COFF debugging information is provided as a series of directives + (.def, .scl, etc.). We build up information as we read the + directives in the following static variables, and file it away when + we reach the .endef directive. */ +static char *coff_sym_name; +static type_info_t coff_type; +static sc_t coff_storage_class; +static st_t coff_symbol_type; +static int coff_is_function; +static char *coff_tag; +static long coff_value; /* FIXME: Might be 64 bits. */ +symbolS *coff_sym_value; +static int coff_inside_enumeration; + +/* Handle a .def directive: start defining a symbol. */ + +static void +obj_ecoff_def (ignore) + int ignore; +{ + char *name; + char name_end; + + SKIP_WHITESPACES (); + + name = input_line_pointer; + name_end = get_symbol_end (); + + if (coff_sym_name != (char *) NULL) + as_warn (".def pseudo-op used inside of .def/.endef; ignored"); + else if (*name == '\0') + as_warn ("Empty symbol name in .def; ignored"); + else + { + if (coff_sym_name != (char *) NULL) + free (coff_sym_name); + if (coff_tag != (char *) NULL) + free (coff_tag); + coff_sym_name = (char *) xmalloc (strlen (name) + 1); + strcpy (coff_sym_name, name); + coff_type = type_info_init; + coff_storage_class = sc_Nil; + coff_symbol_type = st_Nil; + coff_is_function = 0; + coff_tag = (char *) NULL; + coff_value = 0; + coff_sym_value = (symbolS *) NULL; + } + + *input_line_pointer = name_end; + + demand_empty_rest_of_line (); +} + +/* Handle a .dim directive, used to give dimensions for an array. The + arguments are comma separated numbers. mips-tfile assumes that + there will not be more than 6 dimensions, and gdb won't read any + more than that anyhow, so I will also make that assumption. */ + +static void +obj_ecoff_dim (ignore) + int ignore; +{ + int dimens[N_TQ]; + int i; + + if (coff_sym_name == (char *) NULL) + { + as_warn (".dim pseudo-op used outside of .def/.endef; ignored"); + demand_empty_rest_of_line (); + return; + } + + for (i = 0; i < N_TQ; i++) + { + SKIP_WHITESPACES (); + dimens[i] = get_absolute_expression (); + if (*input_line_pointer == ',') + ++input_line_pointer; + else + { + if (*input_line_pointer != '\n' + && *input_line_pointer != ';') + as_warn ("Badly formed .dim directive"); + break; + } + } + + if (i == N_TQ) + --i; + + /* The dimensions are stored away in reverse order. */ + for (; i >= 0; i--) + { + if (coff_type.num_dims >= N_TQ) + { + as_warn ("Too many .dim entries"); + break; + } + coff_type.dimensions[coff_type.num_dims] = dimens[i]; + ++coff_type.num_dims; + } + + demand_empty_rest_of_line (); +} + +/* Handle a .scl directive, which sets the COFF storage class of the + symbol. */ + +static void +obj_ecoff_scl (ignore) + int ignore; +{ + long val; + + if (coff_sym_name == (char *) NULL) + { + as_warn (".scl pseudo-op used outside of .def/.endef; ignored"); + demand_empty_rest_of_line (); + return; + } + + val = get_absolute_expression (); + + /* If the symbol is a static or external, we have already gotten the + appropriate type and class, so make sure we don't override those + values. This is needed because there are some type and classes + that are not in COFF, such as short data, etc. */ + if (coff_symbol_type == st_Nil) + { + coff_symbol_type = map_coff_sym_type[val]; + coff_storage_class = map_coff_storage[val]; + } + + demand_empty_rest_of_line (); +} + +/* Handle a .size directive. For some reason mips-tfile.c thinks that + .size can have multiple arguments. We humor it, although gcc will + never generate more than one argument. */ + +static void +obj_ecoff_size (ignore) + int ignore; +{ + int sizes[N_TQ]; + int i; + + if (coff_sym_name == (char *) NULL) + { + as_warn (".size pseudo-op used outside of .def/.endef; ignored"); + demand_empty_rest_of_line (); + return; + } + + for (i = 0; i < N_TQ; i++) + { + SKIP_WHITESPACES (); + sizes[i] = get_absolute_expression (); + if (*input_line_pointer == ',') + ++input_line_pointer; + else + { + if (*input_line_pointer != '\n' + && *input_line_pointer != ';') + as_warn ("Badly formed .size directive"); + break; + } + } + + if (i == N_TQ) + --i; + + /* The sizes are stored away in reverse order. */ + for (; i >= 0; i--) + { + if (coff_type.num_sizes >= N_TQ) + { + as_warn ("Too many .size entries"); + break; + } + coff_type.sizes[coff_type.num_sizes] = sizes[i]; + ++coff_type.num_sizes; + } + + demand_empty_rest_of_line (); +} + +/* Handle the .type directive, which gives the COFF type of the + symbol. */ + +static void +obj_ecoff_type (ignore) + int ignore; +{ + long val; + tq_t *tq_ptr; + + if (coff_sym_name == (char *) NULL) + { + as_warn (".type pseudo-op used outside of .def/.endef; ignored"); + demand_empty_rest_of_line (); + return; + } + + val = get_absolute_expression (); + + coff_type.orig_type = BTYPE (val); + coff_type.basic_type = map_coff_types[coff_type.orig_type]; + + tq_ptr = &coff_type.type_qualifiers[0]; + while (val &~ N_BTMASK) + { + if (tq_ptr == &coff_type.type_qualifiers[N_TQ]) + { + as_warn ("Too derived values in .type argument"); + break; + } + if (ISPTR (val)) + *tq_ptr++ = tq_Ptr; + else if (ISFCN (val)) + *tq_ptr++ = tq_Proc; + else if (ISARY (val)) + *tq_ptr++ = tq_Array; + else + as_fatal ("Unrecognized .type argument"); + + val = DECREF (val); + } + + if (tq_ptr != &coff_type.type_qualifiers[0] && tq_ptr[-1] == tq_Proc) + { + /* If this is a function, ignore it, so that we don't get two + entries (one from the .ent, and one for the .def that + precedes it). Save the type information so that the end + block can properly add it after the begin block index. For + MIPS knows what reason, we must strip off the function type + at this point. */ + coff_is_function = 1; + tq_ptr[-1] = tq_Nil; + } + + demand_empty_rest_of_line (); +} + +/* Handle the .tag directive, which gives the name of a structure, + union or enum. */ + +static void +obj_ecoff_tag (ignore) + int ignore; +{ + char *name; + char name_end; + + if (coff_sym_name == (char *) NULL) + { + as_warn (".tag pseudo-op used outside of .def/.endef; ignored"); + demand_empty_rest_of_line (); + return; + } + + name = input_line_pointer; + name_end = get_symbol_end (); + + coff_tag = (char *) xmalloc (strlen (name) + 1); + strcpy (coff_tag, name); + + *input_line_pointer = name_end; + + demand_empty_rest_of_line (); +} + +/* Handle the .val directive, which gives the value of the symbol. It + may be the name of a static or global symbol. */ + +static void +obj_ecoff_val (ignore) + int ignore; +{ + if (coff_sym_name == (char *) NULL) + { + as_warn (".val pseudo-op used outside of .def/.endef; ignored"); + demand_empty_rest_of_line (); + return; + } + + if (! is_name_beginner ((unsigned char) *input_line_pointer)) + coff_value = get_absolute_expression (); + else + { + char *name; + char name_end; + + name = input_line_pointer; + name_end = get_symbol_end (); + + if (strcmp (name, ".") == 0) + as_warn ("`.val .' not supported"); + else + coff_sym_value = symbol_find_or_make (name); + + *input_line_pointer = name_end; + + /* FIXME: gcc can generate address expressions here in unusual + cases (search for "obscure" in sdbout.c), although this is + very unlikely for a MIPS chip. */ + } + + demand_empty_rest_of_line (); +} + +/* Handle the .endef directive, which terminates processing of COFF + debugging information for a symbol. */ + +static void +obj_ecoff_endef (ignore) + int ignore; +{ + symint_t indx; + localsym_t *sym; + + demand_empty_rest_of_line (); + + if (coff_sym_name == (char *) NULL) + { + as_warn (".endef pseudo-op used before .def; ignored"); + return; + } + + coff_type.extra_sizes = coff_tag != (char *) NULL; + if (coff_type.num_dims > 0) + { + int diff = coff_type.num_dims - coff_type.num_sizes; + int i = coff_type.num_dims - 1; + int j; + + if (coff_type.num_sizes != 1 || diff < 0) + { + as_warn ("Bad COFF debugging info"); + return; + } + + /* If this is an array, make sure the same number of dimensions + and sizes were passed, creating extra sizes for multiply + dimensioned arrays if not passed. */ + coff_type.extra_sizes = 0; + if (diff) + { + j = (sizeof (coff_type.sizes) / sizeof (coff_type.sizes[0])) - 1; + while (j >= 0) + { + coff_type.sizes[j] = (((j - diff) >= 0) + ? coff_type.sizes[j - diff] + : 0); + j--; + } + + coff_type.num_sizes = i + 1; + for (i--; i >= 0; i--) + coff_type.sizes[i] = (coff_type.sizes[i + 1] + / coff_type.dimensions[i + 1]); + } + } + else if (coff_symbol_type == st_Member + && coff_type.num_sizes - coff_type.extra_sizes == 1) + { + /* Is this a bitfield? This is indicated by a structure memeber + having a size field that isn't an array. */ + coff_type.bitfield = 1; + } + + /* Except for enumeration members & begin/ending of scopes, put the + type word in the aux. symbol table. */ + if (coff_symbol_type == st_Block || coff_symbol_type == st_End) + indx = 0; + else if (coff_inside_enumeration) + indx = cur_file_ptr->void_type; + else + { + if (coff_type.basic_type == bt_Struct + || coff_type.basic_type == bt_Union + || coff_type.basic_type == bt_Enum) + { + if (coff_tag == (char *) NULL) + { + as_warn ("No tag specified for %s", coff_sym_name); + return; + } + + coff_type.tag_ptr = get_tag (coff_tag, (localsym_t *) NULL, + coff_type.basic_type); + } + + if (coff_is_function) + { + last_func_type_info = coff_type; + last_func_sym_value = coff_sym_value; + return; + } + + indx = add_aux_sym_tir (&coff_type, + hash_yes, + &cur_file_ptr->thash_head[0]); + } + + /* Do any last minute adjustments that are necessary. */ + switch (coff_symbol_type) + { + default: + break; + + /* For the beginning of structs, unions, and enumerations, the + size info needs to be passed in the value field. */ + case st_Block: + if (coff_type.num_sizes - coff_type.num_dims - coff_type.extra_sizes + != 1) + { + as_warn ("Bad COFF debugging information"); + return; + } + else + coff_value = coff_type.sizes[0]; + + coff_inside_enumeration = (coff_type.orig_type == T_ENUM); + break; + + /* For the end of structs, unions, and enumerations, omit the + name which is always ".eos". This needs to be done last, so + that any error reporting above gives the correct name. */ + case st_End: + free (coff_sym_name); + coff_sym_name = (char *) NULL; + coff_value = 0; + coff_inside_enumeration = 0; + break; + + /* Members of structures and unions that aren't bitfields, need + to adjust the value from a byte offset to a bit offset. + Members of enumerations do not have the value adjusted, and + can be distinguished by indx == indexNil. For enumerations, + update the maximum enumeration value. */ + case st_Member: + if (! coff_type.bitfield && ! coff_inside_enumeration) + coff_value *= 8; + + break; + } + + /* Add the symbol. */ + sym = add_ecoff_symbol (coff_sym_name, + coff_symbol_type, + coff_storage_class, + coff_sym_value, + coff_value, + indx); + + /* deal with struct, union, and enum tags. */ + if (coff_symbol_type == st_Block) + { + /* Create or update the tag information. */ + tag_t *tag_ptr = get_tag (coff_sym_name, + sym, + coff_type.basic_type); + forward_t **pf; + + /* Remember any forward references. */ + for (pf = &sym->forward_ref; + *pf != (forward_t *) NULL; + pf = &(*pf)->next) + ; + *pf = tag_ptr->forward_ref; + tag_ptr->forward_ref = (forward_t *) NULL; + } +} + +/* Parse .end directives. */ + +static void +obj_ecoff_end (ignore) + int ignore; +{ + char *name; + char name_end; + register int ch; + symbolS *ent; + + if (cur_file_ptr == (efdr_t *) NULL) + { + as_warn (".end directive without a preceding .file directive"); + demand_empty_rest_of_line (); + return; + } + + if (cur_proc_ptr == (proc_t *) NULL) + { + as_warn (".end directive without a preceding .ent directive"); + demand_empty_rest_of_line (); + return; + } + + name = input_line_pointer; + name_end = get_symbol_end (); + + ch = *name; + if (! is_name_beginner (ch)) + { + as_warn (".end directive has no name"); + *input_line_pointer = name_end; + demand_empty_rest_of_line (); + return; + } + + /* The value is the distance between the .end directive and the + corresponding symbol. We create a fake symbol to hold the + current location, and put in the offset when we write out the + symbol. */ + ent = symbol_find (name); + if (ent == (symbolS *) NULL) + as_warn (".end directive names unknown symbol"); + else + (void) add_ecoff_symbol (name, st_End, sc_Text, + symbol_new ("L0\001", now_seg, + frag_now_fix (), frag_now), + (symint_t) 0, (symint_t) 0); + + cur_proc_ptr = (proc_t *) NULL; + + *input_line_pointer = name_end; + demand_empty_rest_of_line (); +} + +/* Parse .ent directives. */ + +static void +obj_ecoff_ent (ignore) + int ignore; +{ + char *name; + char name_end; + register int ch; + + if (cur_file_ptr == (efdr_t *) NULL) + add_file ((const char *) NULL, 0); + + if (cur_proc_ptr != (proc_t *) NULL) + { + as_warn ("second .ent directive found before .end directive"); + demand_empty_rest_of_line (); + return; + } + + name = input_line_pointer; + name_end = get_symbol_end (); + + ch = *name; + if (! is_name_beginner (ch)) + { + as_warn (".ent directive has no name"); + *input_line_pointer = name_end; + demand_empty_rest_of_line (); + return; + } + + add_procedure (name); + + *input_line_pointer = name_end; + demand_empty_rest_of_line (); +} + +/* Parse .file directives. */ + +static void +obj_ecoff_file (ignore) + int ignore; +{ + int indx; + char *name; + int len; + + if (cur_proc_ptr != (proc_t *) NULL) + { + as_warn ("No way to handle .file within .ent/.end section"); + demand_empty_rest_of_line (); + return; + } + + indx = (int) get_absolute_expression (); + + /* FIXME: we don't have to save the name here. */ + name = demand_copy_C_string (&len); + + add_file (name, indx - 1); + + demand_empty_rest_of_line (); +} + +/* Parse .fmask directives. */ + +static void +obj_ecoff_fmask (ignore) + int ignore; +{ + long val; + + if (cur_proc_ptr == (proc_t *) NULL) + { + as_warn (".fmask outside of .ent"); + demand_empty_rest_of_line (); + return; + } + + if (get_absolute_expression_and_terminator (&val) != ',') + { + as_warn ("Bad .fmask directive"); + --input_line_pointer; + demand_empty_rest_of_line (); + return; + } + + cur_proc_ptr->pdr.fregmask = val; + cur_proc_ptr->pdr.fregoffset = get_absolute_expression (); + + demand_empty_rest_of_line (); +} + +/* Parse .frame directives. */ + +static void +obj_ecoff_frame (ignore) + int ignore; +{ + long val; + + if (cur_proc_ptr == (proc_t *) NULL) + { + as_warn (".frame outside of .ent"); + demand_empty_rest_of_line (); + return; + } + + cur_proc_ptr->pdr.framereg = tc_get_register (); + + SKIP_WHITESPACE (); + if (*input_line_pointer++ != ',' + || get_absolute_expression_and_terminator (&val) != ',') + { + as_warn ("Bad .frame directive"); + --input_line_pointer; + demand_empty_rest_of_line (); + return; + } + + cur_proc_ptr->pdr.frameoffset = val; + + cur_proc_ptr->pdr.pcreg = tc_get_register (); + + demand_empty_rest_of_line (); +} + +/* Parse .mask directives. */ + +static void +obj_ecoff_mask (ignore) + int ignore; +{ + long val; + + if (cur_proc_ptr == (proc_t *) NULL) + { + as_warn (".mask outside of .ent"); + demand_empty_rest_of_line (); + return; + } + + if (get_absolute_expression_and_terminator (&val) != ',') + { + as_warn ("Bad .mask directive"); + --input_line_pointer; + demand_empty_rest_of_line (); + return; + } + + cur_proc_ptr->pdr.regmask = val; + cur_proc_ptr->pdr.regoffset = get_absolute_expression (); + + demand_empty_rest_of_line (); +} + +/* Parse .loc directives. */ + +static void +obj_ecoff_loc (ignore) + int ignore; +{ + char buf[20]; + lineno_list_t *list; + + if (cur_file_ptr == (efdr_t *) NULL) + { + as_warn (".loc before .file"); + demand_empty_rest_of_line (); + return; + } + + if (now_seg != text_section) + { + as_warn (".loc outside of .text"); + demand_empty_rest_of_line (); + return; + } + + /* FIXME: .loc directives look like ``.loc 1 4'' where the first + number is the file index and the second number is the line + number. Unfortunately, do_scrub_next_char removes the space, + producing ``.loc 14''. Urrrk. I'm afraid I'll break something + if I change do_scrub_next_char, so instead we do this gross hack. + Note that file_index is one less than the value in the .loc, + because we adjusted it by one in the call to add_file. This + actually won't work in the unfortunate circumstance of the same + file appearing twice with different indices with different + numbers of digits, which is possible. */ + SKIP_WHITESPACE (); + input_line_pointer += 1 + (cur_file_ptr->file_index + 1) / 10; + + list = allocate_lineno_list (); + + list->next = (lineno_list_t *) NULL; + list->file = cur_file_ptr; + list->proc = cur_proc_ptr; + list->frag = frag_now; + list->paddr = frag_now_fix (); + list->lineno = get_absolute_expression (); + + /* A .loc directive will sometimes appear before a .ent directive, + which means that cur_proc_ptr will be NULL here. Arrange to + patch this up. */ + if (cur_proc_ptr == (proc_t *) NULL) + { + lineno_list_t **pl; + + pl = &noproc_lineno; + while (*pl != (lineno_list_t *) NULL) + pl = &(*pl)->next; + *pl = list; + } + else + { + *last_lineno_ptr = list; + last_lineno_ptr = &list->next; + } +} + +/* Make sure the @stabs symbol is emitted. */ + +static void +mark_stabs (ignore) + int ignore; +{ + if (! stabs_seen) + { + /* Add a dummy @stabs dymbol. */ + stabs_seen = 1; + (void) add_ecoff_symbol (stabs_symbol, stNil, scInfo, + (symbolS *) NULL, + (symint_t) -1, MIPS_MARK_STAB (0)); + } +} + +/* Parse .stabs directives. + + .stabs directives have five fields: + "string" a string, encoding the type information. + code a numeric code, defined in + 0 a zero + 0 a zero or line number + value a numeric value or an address. + + If the value is relocatable, we transform this into: + iss points as an index into string space + value value from lookup of the name + st st from lookup of the name + sc sc from lookup of the name + index code|CODE_MASK + + If the value is not relocatable, we transform this into: + iss points as an index into string space + value value + st st_Nil + sc sc_Nil + index code|CODE_MASK + + .stabn directives have four fields (string is null): + code a numeric code, defined in + 0 a zero + 0 a zero or a line number + value a numeric value or an address. */ + +static void +obj_ecoff_stab (type) + int type; +{ + char *string; + efdr_t *save_file_ptr = cur_file_ptr; + symint_t code; + symint_t value; + symbolS *sym; + st_t st; + sc_t sc; + + if (stabs_seen == 0) + mark_stabs (0); + + if (type != 's') + string = (char *) NULL; + else + { + int len; + + string = demand_copy_C_string (&len); + SKIP_WHITESPACE (); + if (*input_line_pointer == ',') + input_line_pointer++; + else + { + as_warn ("Bad .stab%c directive", type); + demand_empty_rest_of_line (); + return; + } + } + + code = (symint_t) get_absolute_expression (); + + SKIP_WHITESPACE (); + if (*input_line_pointer++ != ',') + { + as_warn ("Bad .stab%c directive", type); + --input_line_pointer; + demand_empty_rest_of_line (); + return; + } + + if (get_absolute_expression () != 0) + { + as_warn ("Bad .stab%c directive (expected 0)", type); + demand_empty_rest_of_line (); + return; + } + + SKIP_WHITESPACE (); + if (*input_line_pointer++ != ',') + { + as_warn ("Bad .stab%c directive", type); + --input_line_pointer; + demand_empty_rest_of_line (); + return; + } + + /* Line number stabs are handled differently, since they have two values, + the line number and the address of the label. We use the index field + (aka code) to hold the line number, and the value field to hold the + address. The symbol type is st_Label, which should be different from + the other stabs, so that gdb can recognize it. */ + if (code == N_SLINE) + { + SYMR dummy_symr; + char *name; + char name_end; + + code = (symint_t) get_absolute_expression (); + + if (*input_line_pointer++ != ',') + { + as_warn ("Bad .stab%c directive", type); + --input_line_pointer; + demand_empty_rest_of_line (); + return; + } + + dummy_symr.index = code; + if (dummy_symr.index != code) + { + as_warn ("Line number (%d) for .stab%c directive cannot fit in index field (20 bits)", + code, type); + demand_empty_rest_of_line (); + return; + } + + SKIP_WHITESPACE (); + name = input_line_pointer; + name_end = get_symbol_end (); + + sym = symbol_find_or_make (name); + *input_line_pointer = name_end; + + value = 0; + st = st_Label; + sc = sc_Undefined; + } + else + { + /* Skip 0, */ + if (get_absolute_expression () != 0) + { + as_warn ("Bad .stab%c directive (expected 0)", type); + demand_empty_rest_of_line (); + return; + } + + SKIP_WHITESPACE (); + if (*input_line_pointer++ != ',') + { + as_warn ("Bad .stab%c directive", type); + --input_line_pointer; + demand_empty_rest_of_line (); + return; + } + + SKIP_WHITESPACE (); + if (isdigit (*input_line_pointer) + || *input_line_pointer == '-' + || *input_line_pointer == '+') + { + st = st_Nil; + sc = sc_Nil; + sym = (symbolS *) NULL; + value = get_absolute_expression (); + } + else if (! is_name_beginner ((unsigned char) *input_line_pointer)) + { + as_warn ("Illegal .stab%c directive, bad character", type); + demand_empty_rest_of_line (); + return; + } + else + { + char *name; + char name_end; + + name = input_line_pointer; + name_end = get_symbol_end (); + + sym = symbol_find_or_make (name); + + /* Traditionally, N_LBRAC and N_RBRAC are *not* relocated. */ + if (code == N_LBRAC || code == N_RBRAC) + { + sc = sc_Nil; + st = st_Nil; + } + else + { + sc = sc_Undefined; + st = st_Nil; + } + value = 0; + + *input_line_pointer = name_end; + if (name_end == '+' || name_end == '-') + { + ++input_line_pointer; + value = get_absolute_expression (); + if (name_end == '-') + value = - value; + } + } + + code = MIPS_MARK_STAB (code); + } + + (void) add_ecoff_symbol (string, st, sc, sym, value, code); + + /* Restore normal file type. */ + cur_file_ptr = save_file_ptr; +} + +/* Add bytes to the symbolic information buffer. */ + +static char * +ecoff_add_bytes (buf, bufend, bufptr, need) + char **buf; + char **bufend; + char *bufptr; + long need; +{ + unsigned long at; + unsigned long want; + + at = bufptr - *buf; + need -= *bufend - bufptr; + if (need < PAGE_SIZE) + need = PAGE_SIZE; + want = (*bufend - *buf) + need; + *buf = xrealloc (*buf, want); + *bufend = *buf + want; + return *buf + at; +} + +/* Adjust the symbolic information buffer to a longword boundary. */ + +static long +ecoff_longword_adjust (buf, bufend, offset, bufptrptr) + char **buf; + char **bufend; + long offset; + char **bufptrptr; +{ + if ((offset & 3) != 0) + { + long add; + + add = 4 - (offset & 3); + if (*bufend - (*buf + offset) < add) + (void) ecoff_add_bytes (buf, bufend, *buf + offset, add); + offset += add; + if (bufptrptr != (char **) NULL) + *bufptrptr = *buf + offset; + } + + return offset; +} + +/* Build the line number information. */ + +static long +ecoff_build_lineno (buf, bufend, offset, linecntptr) + char **buf; + char **bufend; + long offset; + long *linecntptr; +{ + char *bufptr; + register lineno_list_t *l; + lineno_list_t *last; + efdr_t *file; + proc_t *proc; + long c; + long iline; + + bufptr = *buf + offset; + + file = (efdr_t *) NULL; + proc = (proc_t *) NULL; + last = (lineno_list_t *) NULL; + c = offset; + iline = 0; + for (l = first_lineno; l != (lineno_list_t *) NULL; l = l->next) + { + long count; + long delta; + int didone; + + if (l->file != file || l->proc != proc) + { + if (l->proc != proc && proc != (proc_t *) NULL) + proc->pdr.lnHigh = last->lineno; + if (l->file != file && file != (efdr_t *) NULL) + { + file->fdr.cbLine = c - file->fdr.cbLineOffset; + file->fdr.cline = iline - file->fdr.ilineBase; + } + + c = ecoff_longword_adjust (buf, bufend, c, &bufptr); + + if (l->file != file) + { + file = l->file; + file->fdr.ilineBase = iline; + file->fdr.cbLineOffset = c; + } + if (l->proc != proc) + { + proc = l->proc; + if (proc != (proc_t *) NULL) + { + /* The iline field is ill-documented. This is a + guess at the right value. */ + proc->pdr.iline = l->frag->fr_address + l->paddr; + proc->pdr.lnLow = l->lineno; + proc->pdr.cbLineOffset = c - file->fdr.cbLineOffset; + } + } + + last = (lineno_list_t *) NULL; + } + + /* Get the offset to the memory address of the next line number + (in words). */ + if (l->next == (lineno_list_t *) NULL) + count = 0; + else + { + count = (((l->next->frag->fr_address + l->next->paddr + - (l->frag->fr_address + l->paddr)) + >> 2) + - 1); + if (count < 0) + { + /* Don't change last, so we still get the right delta. */ + continue; + } + } + + /* Get the offset to this line number. */ + if (last == (lineno_list_t *) NULL) + delta = 0; + else + delta = l->lineno - last->lineno; + + /* We can only adjust the address by 16 words at a time. */ + didone = 0; + while (count > 0x10) + { + if (bufptr >= *bufend) + bufptr = ecoff_add_bytes (buf, bufend, bufptr, (long) 1); + if (delta >= 7) + { + *bufptr++ = 0x0f + (7 << 4); + delta -= 7; + } + else if (delta <= -7) + { + *bufptr++ = 0x0f + (9 << 4); + delta += 7; + } + else + { + *bufptr++ = 0x0f + (delta << 4); + delta = 0; + } + ++c; + count -= 0x10; + didone = 1; + } + + /* Put in the offset to this line number. */ + while (delta != 0 || ! didone) + { + if (delta >= -7 && delta <= 7) + { + if (bufptr >= *bufend) + bufptr = ecoff_add_bytes (buf, bufend, bufptr, (long) 1); + *bufptr++ = count + (delta << 4); + delta = 0; + ++c; + } + else + { + int set; + + if (*bufend - bufptr < 3) + bufptr = ecoff_add_bytes (buf, bufend, bufptr, (long) 3); + *bufptr++ = count + (8 << 4); + if (delta < -0x8000) + { + set = -0x8000; + delta += 0x8000; + } + else if (delta > 0x7fff) + { + set = 0x7fff; + delta -= 0x7fff; + } + else + { + set = delta; + delta = 0; + } + *bufptr++ = set >> 8; + *bufptr++ = set & 0xffff; + c += 3; + } + count = 0; + didone = 1; + } + + ++iline; + last = l; + } + + if (proc != (proc_t *) NULL) + proc->pdr.lnHigh = last->lineno; + if (file != (efdr_t *) NULL) + { + file->fdr.cbLine = c - file->fdr.cbLineOffset; + file->fdr.cline = iline - file->fdr.ilineBase; + } + + c = ecoff_longword_adjust (buf, bufend, c, &bufptr); + + if (linecntptr != (long *) NULL) + *linecntptr = iline; + + return c; +} + +/* Build and swap out the symbols. */ + +static long +ecoff_build_symbols (buf, + bufend, + offset, + extbuf, + extbufend, + extoffset, + ext_strings, + ext_str_hash) + char **buf; + char **bufend; + long offset; + char **extbuf; + char **extbufend; + long *extoffset; + varray_t *ext_strings; + struct hash_control *ext_str_hash; +{ + struct sym_ext *sym_out; + struct ext_ext *ext_out; + long isym; + long iext; + vlinks_t *file_link; + + sym_out = (struct sym_ext *) (*buf + offset); + ext_out = (struct ext_ext *) (*extbuf + *extoffset); + + isym = 0; + iext = 0; + + /* The symbols are stored by file. */ + for (file_link = file_desc.first; + file_link != (vlinks_t *) NULL; + file_link = file_link->next) + { + int ifilesym; + int fil_cnt; + efdr_t *fil_ptr; + efdr_t *fil_end; + + ifilesym = isym; + + if (file_link->next == (vlinks_t *) NULL) + fil_cnt = file_desc.objects_last_page; + else + fil_cnt = file_desc.objects_per_page; + fil_ptr = file_link->datum->file; + fil_end = fil_ptr + fil_cnt; + for (; fil_ptr < fil_end; fil_ptr++) + { + vlinks_t *sym_link; + + fil_ptr->fdr.isymBase = isym; + for (sym_link = fil_ptr->symbols.first; + sym_link != (vlinks_t *) NULL; + sym_link = sym_link->next) + { + int sym_cnt; + localsym_t *sym_ptr; + localsym_t *sym_end; + + if (sym_link->next == (vlinks_t *) NULL) + sym_cnt = fil_ptr->symbols.objects_last_page; + else + sym_cnt = fil_ptr->symbols.objects_per_page; + sym_ptr = sym_link->datum->sym; + sym_end = sym_ptr + sym_cnt; + for (; sym_ptr < sym_end; sym_ptr++) + { + int local; + forward_t *f; + + know (sym_ptr->file_ptr == fil_ptr); + + /* If there is no associated gas symbol, then this + is a pure debugging symbol. We have already + added the name (if any) to fil_ptr->strings. + Otherwise we must decide whether this is an + external or a local symbol (actually, it may be + both if the local provides additional debugging + information for the external). */ + local = 1; + if (sym_ptr->as_sym != (symbolS *) NULL) + { + sym_ptr->ecoff_sym.value = S_GET_VALUE (sym_ptr->as_sym); + + /* This is just an external symbol if it is + outside a procedure and it has a type. */ + if ((S_IS_EXTERNAL (sym_ptr->as_sym) + || ! S_IS_DEFINED (sym_ptr->as_sym)) + && sym_ptr->proc_ptr == (proc_t *) NULL + && sym_ptr->ecoff_sym.st != (int) st_Nil) + local = 0; + + /* If an st_end symbol has an associated gas + symbol, then it is a fake created for a .bend + or .end directive. */ + if (local && sym_ptr->ecoff_sym.st != st_End) + sym_ptr->ecoff_sym.iss = + add_string (&fil_ptr->strings, + fil_ptr->str_hash, + S_GET_NAME (sym_ptr->as_sym), + (shash_t **) NULL); + } + + /* We now know the index of this symbol; fill in + locations that have been waiting for that + information. */ + if (sym_ptr->begin_ptr != (localsym_t *) NULL) + { + localsym_t *begin_ptr; + st_t begin_type; + + know (local); + begin_ptr = sym_ptr->begin_ptr; + know (begin_ptr->sym_index != -1); + sym_ptr->ecoff_sym.index = begin_ptr->sym_index; + if (sym_ptr->ecoff_sym.sc != (int) sc_Info) + sym_ptr->ecoff_sym.iss = begin_ptr->ecoff_sym.iss; + + begin_type = begin_ptr->ecoff_sym.st; + if (begin_type == st_File + || begin_type == st_Block) + { + begin_ptr->ecoff_sym.index = isym - ifilesym + 1; + ecoff_swap_sym_out (stdoutput, + &begin_ptr->ecoff_sym, + (((struct sym_ext *) + (*buf + offset)) + + begin_ptr->sym_index)); + } + else + { + know (sym_ptr->begin_ptr->index_ptr + != (aux_t *) NULL); + sym_ptr->begin_ptr->index_ptr->data.isym = + isym - ifilesym + 1; + } + + /* The value of the symbol marking the end of a + procedure or block is the size of the + procedure or block. */ + if (begin_type == st_Proc || begin_type == st_Block) + { + know (sym_ptr->as_sym != (symbolS *) NULL); + know (begin_ptr->as_sym != (symbolS *) NULL); + sym_ptr->ecoff_sym.value = + (S_GET_VALUE (sym_ptr->as_sym) + - S_GET_VALUE (begin_ptr->as_sym)); + } + } + + for (f = sym_ptr->forward_ref; + f != (forward_t *) NULL; + f = f->next) + { + know (local); + f->ifd_ptr->data.isym = fil_ptr->file_index; + f->index_ptr->data.rndx.index = isym - ifilesym; + } + + if (local) + { + if (*bufend - (char *) sym_out < sizeof (struct sym_ext)) + sym_out = ((struct sym_ext *) + ecoff_add_bytes (buf, bufend, + (char *) sym_out, + sizeof (struct sym_ext))); + ecoff_swap_sym_out (stdoutput, &sym_ptr->ecoff_sym, + sym_out); + ++sym_out; + sym_ptr->sym_index = isym; + ++isym; + + if (sym_ptr->proc_ptr != (proc_t *) NULL + && sym_ptr->proc_ptr->sym == sym_ptr) + sym_ptr->proc_ptr->pdr.isym = isym - ifilesym; + } + + /* If this is an external symbol, swap it out. */ + if (sym_ptr->as_sym != (symbolS *) NULL + && (S_IS_EXTERNAL (sym_ptr->as_sym) + || ! S_IS_DEFINED (sym_ptr->as_sym))) + { + EXTR ext; + + memset (&ext, 0, sizeof ext); + ext.asym = sym_ptr->ecoff_sym; + ext.ifd = fil_ptr->file_index; + ext.asym.iss = add_string (ext_strings, + ext_str_hash, + S_GET_NAME (sym_ptr->as_sym), + (shash_t **) NULL); + if (*extbufend - (char *) ext_out + < sizeof (struct ext_ext)) + ext_out = ((struct ext_ext *) + ecoff_add_bytes (extbuf, extbufend, + (char *) ext_out, + sizeof (struct ext_ext))); + ecoff_swap_ext_out (stdoutput, &ext, ext_out); + ecoff_set_sym_index (sym_ptr->as_sym->bsym, iext); + ++ext_out; + ++iext; + } + } + } + fil_ptr->fdr.csym = isym - fil_ptr->fdr.isymBase; + } + } + + *extoffset += iext * sizeof (struct ext_ext); + return offset + isym * sizeof (struct sym_ext); +} + +/* Swap out the procedure information. */ + +static long +ecoff_build_procs (buf, bufend, offset) + char **buf; + char **bufend; + long offset; +{ + struct pdr_ext *pdr_out; + long iproc; + vlinks_t *file_link; + + pdr_out = (struct pdr_ext *) (*buf + offset); + + iproc = 0; + + /* The procedures are stored by file. */ + for (file_link = file_desc.first; + file_link != (vlinks_t *) NULL; + file_link = file_link->next) + { + int fil_cnt; + efdr_t *fil_ptr; + efdr_t *fil_end; + + if (file_link->next == (vlinks_t *) NULL) + fil_cnt = file_desc.objects_last_page; + else + fil_cnt = file_desc.objects_per_page; + fil_ptr = file_link->datum->file; + fil_end = fil_ptr + fil_cnt; + for (; fil_ptr < fil_end; fil_ptr++) + { + vlinks_t *proc_link; + int first; + + fil_ptr->fdr.ipdFirst = iproc; + first = 1; + for (proc_link = fil_ptr->procs.first; + proc_link != (vlinks_t *) NULL; + proc_link = proc_link->next) + { + int proc_cnt; + proc_t *proc_ptr; + proc_t *proc_end; + + if (proc_link->next == (vlinks_t *) NULL) + proc_cnt = fil_ptr->procs.objects_last_page; + else + proc_cnt = fil_ptr->procs.objects_per_page; + proc_ptr = proc_link->datum->proc; + proc_end = proc_ptr + proc_cnt; + for (; proc_ptr < proc_end; proc_ptr++) + { + unsigned long adr; + + adr = S_GET_VALUE (proc_ptr->sym->as_sym); + if (first) + { + fil_ptr->fdr.adr = adr; + first = 0; + } + proc_ptr->pdr.adr = adr - fil_ptr->fdr.adr; + if (*bufend - (char *) pdr_out < sizeof (struct pdr_ext)) + pdr_out = ((struct pdr_ext *) + ecoff_add_bytes (buf, bufend, + (char *) pdr_out, + sizeof (struct pdr_ext))); + ecoff_swap_pdr_out (stdoutput, &proc_ptr->pdr, pdr_out); + ++pdr_out; + ++iproc; + } + } + fil_ptr->fdr.cpd = iproc - fil_ptr->fdr.ipdFirst; + } + } + + return offset + iproc * sizeof (struct pdr_ext); +} + +/* Swap out the aux information. */ + +static long +ecoff_build_aux (buf, bufend, offset) + char **buf; + char **bufend; + long offset; +{ + int bigendian; + union aux_ext *aux_out; + long iaux; + vlinks_t *file_link; + + bigendian = stdoutput->xvec->header_byteorder_big_p; + + aux_out = (union aux_ext *) (*buf + offset); + + iaux = 0; + + /* The aux entries are stored by file. */ + for (file_link = file_desc.first; + file_link != (vlinks_t *) NULL; + file_link = file_link->next) + { + int fil_cnt; + efdr_t *fil_ptr; + efdr_t *fil_end; + + if (file_link->next == (vlinks_t *) NULL) + fil_cnt = file_desc.objects_last_page; + else + fil_cnt = file_desc.objects_per_page; + fil_ptr = file_link->datum->file; + fil_end = fil_ptr + fil_cnt; + for (; fil_ptr < fil_end; fil_ptr++) + { + vlinks_t *aux_link; + + fil_ptr->fdr.fBigendian = bigendian; + fil_ptr->fdr.iauxBase = iaux; + for (aux_link = fil_ptr->aux_syms.first; + aux_link != (vlinks_t *) NULL; + aux_link = aux_link->next) + { + int aux_cnt; + aux_t *aux_ptr; + aux_t *aux_end; + + if (aux_link->next == (vlinks_t *) NULL) + aux_cnt = fil_ptr->aux_syms.objects_last_page; + else + aux_cnt = fil_ptr->aux_syms.objects_per_page; + aux_ptr = aux_link->datum->aux; + aux_end = aux_ptr + aux_cnt; + for (; aux_ptr < aux_end; aux_ptr++) + { + if (*bufend - (char *) aux_out < sizeof (union aux_ext)) + aux_out = ((union aux_ext *) + ecoff_add_bytes (buf, bufend, + (char *) aux_out, + sizeof (union aux_ext))); + switch (aux_ptr->type) + { + case aux_tir: + ecoff_swap_tir_out (bigendian, &aux_ptr->data.ti, + &aux_out->a_ti); + break; + case aux_rndx: + ecoff_swap_rndx_out (bigendian, &aux_ptr->data.rndx, + &aux_out->a_rndx); + break; + case aux_dnLow: + AUX_PUT_DNLOW (bigendian, aux_ptr->data.dnLow, + aux_out); + break; + case aux_dnHigh: + AUX_PUT_DNHIGH (bigendian, aux_ptr->data.dnHigh, + aux_out); + break; + case aux_isym: + AUX_PUT_ISYM (bigendian, aux_ptr->data.isym, + aux_out); + break; + case aux_iss: + AUX_PUT_ISS (bigendian, aux_ptr->data.iss, + aux_out); + break; + case aux_width: + AUX_PUT_WIDTH (bigendian, aux_ptr->data.width, + aux_out); + break; + case aux_count: + AUX_PUT_COUNT (bigendian, aux_ptr->data.count, + aux_out); + break; + } + + ++aux_out; + ++iaux; + } + } + fil_ptr->fdr.caux = iaux - fil_ptr->fdr.iauxBase; + } + } + + return offset + iaux * sizeof (union aux_ext); +} + +/* Copy out the strings from a varray_t. This returns the number of + bytes copied, rather than the new offset. */ + +static long +ecoff_build_strings (buf, bufend, offset, vp) + char **buf; + char **bufend; + long offset; + varray_t *vp; +{ + long istr; + char *str_out; + vlinks_t *str_link; + + str_out = *buf + offset; + + istr = 0; + + for (str_link = vp->first; + str_link != (vlinks_t *) NULL; + str_link = str_link->next) + { + long str_cnt; + + if (str_link->next == (vlinks_t *) NULL) + str_cnt = vp->objects_last_page; + else + str_cnt = vp->objects_per_page; + + if (*bufend - str_out < str_cnt) + str_out = ecoff_add_bytes (buf, bufend, str_out, str_cnt); + + memcpy (str_out, str_link->datum->byte, str_cnt); + str_out += str_cnt; + istr += str_cnt; + } + + return istr; +} + +/* Dump out the local strings. */ + +static long +ecoff_build_ss (buf, bufend, offset) + char **buf; + char **bufend; + long offset; +{ + long iss; + vlinks_t *file_link; + + iss = 0; + + for (file_link = file_desc.first; + file_link != (vlinks_t *) NULL; + file_link = file_link->next) + { + int fil_cnt; + efdr_t *fil_ptr; + efdr_t *fil_end; + + if (file_link->next == (vlinks_t *) NULL) + fil_cnt = file_desc.objects_last_page; + else + fil_cnt = file_desc.objects_per_page; + fil_ptr = file_link->datum->file; + fil_end = fil_ptr + fil_cnt; + for (; fil_ptr < fil_end; fil_ptr++) + { + long ss_cnt; + + fil_ptr->fdr.issBase = iss; + ss_cnt = ecoff_build_strings (buf, bufend, offset + iss, + &fil_ptr->strings); + fil_ptr->fdr.cbSs = ss_cnt; + iss += ss_cnt; + } + } + + return ecoff_longword_adjust (buf, bufend, offset + iss, (char **) NULL); +} + +/* Swap out the file descriptors. */ + +static long +ecoff_build_fdr (buf, bufend, offset) + char **buf; + char **bufend; + long offset; +{ + long ifile; + struct fdr_ext *fdr_out; + vlinks_t *file_link; + + ifile = 0; + + fdr_out = (struct fdr_ext *) (*buf + offset); + + for (file_link = file_desc.first; + file_link != (vlinks_t *) NULL; + file_link = file_link->next) + { + int fil_cnt; + efdr_t *fil_ptr; + efdr_t *fil_end; + + if (file_link->next == (vlinks_t *) NULL) + fil_cnt = file_desc.objects_last_page; + else + fil_cnt = file_desc.objects_per_page; + fil_ptr = file_link->datum->file; + fil_end = fil_ptr + fil_cnt; + for (; fil_ptr < fil_end; fil_ptr++) + { + if (*bufend - (char *) fdr_out < sizeof (struct fdr_ext)) + fdr_out = ((struct fdr_ext *) + ecoff_add_bytes (buf, bufend, (char *) fdr_out, + sizeof (struct fdr_ext))); + ecoff_swap_fdr_out (stdoutput, &fil_ptr->fdr, fdr_out); + ++fdr_out; + ++ifile; + } + } + + return offset + ifile * sizeof (struct fdr_ext); +} + +/* Set the vma for all the sections. */ + +static void +ecoff_set_vma () +{ + register bfd_vma addr; + register asection *sec; + + addr = 0; + for (sec = stdoutput->sections; sec != (asection *) NULL; sec = sec->next) + { + bfd_set_section_vma (stdoutput, sec, addr); + addr += bfd_section_size (stdoutput, sec); + } +} + +/* Adjust the value of a symbol by the vma of the section. */ + +void +ecoff_frob_symbol (sym) + symbolS *sym; +{ + static int setvma = 0; + + if (! setvma) + { + ecoff_set_vma (); + setvma = 1; + } + + S_SET_VALUE (sym, + (S_GET_VALUE (sym) + + bfd_get_section_vma (stdoutput, + bfd_get_section (sym->bsym)))); +} + +/* Swap out the symbols and debugging information for BFD. */ + +void +ecoff_frob_file () +{ + efdr_t *fil_ptr; + efdr_t *hold_file_ptr; + proc_t * hold_proc_ptr; + symbolS *sym; + HDRR *hdr; + char *buf; + char *bufend; + long offset; + char *extbuf; + char *extbufend; + long extoffset; + varray_t ext_strings; + static varray_t init_ext_strings = INIT_VARRAY (char); + struct hash_control *ext_str_hash; + char *set; + + /* Output an ending symbol for all the files. We have to do this + here for the last file, so we may as well do it for all of the + files. */ + for (fil_ptr = first_file; + fil_ptr != (efdr_t *) NULL; + fil_ptr = fil_ptr->next_file) + { + cur_file_ptr = fil_ptr; + (void) add_ecoff_symbol ((const char *) NULL, + st_End, sc_Text, + (symbolS *) NULL, + (symint_t) 0, + (symint_t) 0); + } + + /* Look through the symbols. Add debugging information for each + symbol that has not already received it. */ + hold_file_ptr = cur_file_ptr; + hold_proc_ptr = cur_proc_ptr; + cur_proc_ptr = (proc_t *) NULL; + for (sym = symbol_rootP; sym != (symbolS *) NULL; sym = symbol_next (sym)) + { + st_t st; + sc_t sc; + + if (sym->ecoff_symbol + || sym->ecoff_file == (efdr_t *) NULL) + continue; + + if (S_IS_EXTERNAL (sym) || ! S_IS_DEFINED (sym)) + st = st_Global; + else if (S_GET_SEGMENT (sym) == text_section) + st = st_Label; + else + st = st_Static; + + if (! S_IS_DEFINED (sym)) + sc = sc_Undefined; + else if (S_IS_COMMON (sym)) + sc = sc_Common; + else if (S_GET_SEGMENT (sym) == text_section) + sc = sc_Text; + else if (S_GET_SEGMENT (sym) == data_section) + sc = sc_Data; + else if (S_GET_SEGMENT (sym) == bss_section) + sc = sc_Bss; + else + abort (); + + cur_file_ptr = sym->ecoff_file; + add_ecoff_symbol (S_GET_NAME (sym), st, sc, sym, + S_GET_VALUE (sym), indexNil); + } + cur_proc_ptr = hold_proc_ptr; + cur_file_ptr = hold_file_ptr; + + /* Build the symbolic information. */ + hdr = &ecoff_data (stdoutput)->symbolic_header; + offset = 0; + buf = xmalloc (PAGE_SIZE); + bufend = buf + PAGE_SIZE; + + /* Build the line number information. */ + hdr->cbLineOffset = offset; + offset = ecoff_build_lineno (&buf, &bufend, offset, &hdr->ilineMax); + hdr->cbLine = offset - hdr->cbLineOffset; + + /* We don't use dense numbers at all. */ + hdr->idnMax = 0; + hdr->cbDnOffset = 0; + + /* We can't build the PDR table until we have built the symbols, + because a PDR contains a symbol index. However, we set aside + space at this point. */ + hdr->ipdMax = proc_cnt; + hdr->cbPdOffset = offset; + if (bufend - (buf + offset) < proc_cnt * sizeof (struct pdr_ext)) + (void) ecoff_add_bytes (&buf, &bufend, buf + offset, + proc_cnt * sizeof (struct pdr_ext)); + offset += proc_cnt * sizeof (struct pdr_ext); + + /* Build the symbols. It's convenient to build both the local and + external symbols at the same time. We can put the local symbols + directly into the buffer, but we have to hold the external + symbols apart until we know where they are going to go. */ + extbuf = xmalloc (PAGE_SIZE); + extbufend = extbuf + PAGE_SIZE; + extoffset = 0; + ext_strings = init_ext_strings; + ext_str_hash = hash_new (); + hdr->cbSymOffset = offset; + offset = ecoff_build_symbols (&buf, &bufend, offset, + &extbuf, &extbufend, &extoffset, + &ext_strings, ext_str_hash); + hdr->isymMax = (offset - hdr->cbSymOffset) / sizeof (struct sym_ext); + + /* Building the symbols initializes the symbol index in the PDR's. + Now we can swap out the PDR's. */ + (void) ecoff_build_procs (&buf, &bufend, hdr->cbPdOffset); + + /* We don't use optimization symbols. */ + hdr->ioptMax = 0; + hdr->cbOptOffset = 0; + + /* Swap out the auxiliary type information. */ + hdr->cbAuxOffset = offset; + offset = ecoff_build_aux (&buf, &bufend, offset); + hdr->iauxMax = (offset - hdr->cbAuxOffset) / sizeof (union aux_ext); + + /* Copy out the local strings. */ + hdr->cbSsOffset = offset; + offset = ecoff_build_ss (&buf, &bufend, offset); + hdr->issMax = offset - hdr->cbSsOffset; + + /* Copy out the external strings. */ + hdr->cbSsExtOffset = offset; + offset += ecoff_build_strings (&buf, &bufend, offset, &ext_strings); + offset = ecoff_longword_adjust (&buf, &bufend, offset, (char **) NULL); + hdr->issExtMax = offset - hdr->cbSsExtOffset; + + /* We don't use relative file descriptors. */ + hdr->crfd = 0; + hdr->cbRfdOffset = 0; + + /* Swap out the file descriptors. */ + hdr->cbFdOffset = offset; + offset = ecoff_build_fdr (&buf, &bufend, offset); + hdr->ifdMax = (offset - hdr->cbFdOffset) / sizeof (struct fdr_ext); + + /* Copy out the external symbols. */ + hdr->cbExtOffset = offset; + if (bufend - (buf + offset) < extoffset) + (void) ecoff_add_bytes (&buf, &bufend, buf + offset, extoffset); + memcpy (buf + offset, extbuf, extoffset); + offset += extoffset; + hdr->iextMax = (offset - hdr->cbExtOffset) / sizeof (struct ext_ext); + + know ((offset & 3) == 0); + + /* That completes the symbolic debugging information. We must now + finish up the symbolic header and the ecoff_tdata structure. */ + set = buf; +#define SET(ptr, count, type) \ + ecoff_data (stdoutput)->ptr = (type *) set; \ + set += hdr->count * sizeof (type) + + SET (line, cbLine, unsigned char); + SET (external_dnr, idnMax, struct dnr_ext); + SET (external_pdr, ipdMax, struct pdr_ext); + SET (external_sym, isymMax, struct sym_ext); + SET (external_opt, ioptMax, struct opt_ext); + SET (external_aux, iauxMax, union aux_ext); + SET (ss, issMax, char); + SET (ssext, issExtMax, char); + SET (external_rfd, crfd, struct rfd_ext); + SET (external_fdr, ifdMax, struct fdr_ext); + SET (external_ext, iextMax, struct ext_ext); + +#undef SET + + /* FIXME: set the gp value. */ + + /* FIXME: set the register masks. */ + + ecoff_data (stdoutput)->raw_size = offset; + ecoff_data (stdoutput)->raw_syments = buf; + + hdr->magic = magicSym; + /* FIXME: what should hdr->vstamp be? */ +} + +/* Allocate a cluster of pages. */ + +#ifndef MALLOC_CHECK + +static page_t * +allocate_cluster (npages) + unsigned long npages; +{ + register page_t *value = (page_t *) xmalloc (npages * PAGE_USIZE); + +#ifdef ECOFF_DEBUG + if (debug > 3) + fprintf (stderr, "\talloc\tnpages = %d, value = 0x%.8x\n", npages, value); +#endif + + memset (value, 0, npages * PAGE_USIZE); + + return value; +} + + +static page_t *cluster_ptr = NULL; +static unsigned long pages_left = 0; + +#endif /* MALLOC_CHECK */ + +/* Allocate one page (which is initialized to 0). */ + +static page_t * +allocate_page () +{ +#ifndef MALLOC_CHECK + + if (pages_left == 0) + { + pages_left = MAX_CLUSTER_PAGES; + cluster_ptr = allocate_cluster (pages_left); + } + + pages_left--; + return cluster_ptr++; + +#else /* MALLOC_CHECK */ + + page_t *ptr; + + ptr = xmalloc (PAGE_USIZE); + memset (ptr, 0, PAGE_USIZE); + return ptr; + +#endif /* MALLOC_CHECK */ +} + +/* Allocate scoping information. */ + +static scope_t * +allocate_scope () +{ + register scope_t *ptr; + static scope_t initial_scope; + +#ifndef MALLOC_CHECK + + ptr = alloc_counts[(int)alloc_type_scope].free_list.f_scope; + if (ptr != (scope_t *) NULL) + alloc_counts[ (int)alloc_type_scope ].free_list.f_scope = ptr->free; + else + { + register int unallocated = alloc_counts[(int)alloc_type_scope].unallocated; + register page_t *cur_page = alloc_counts[(int)alloc_type_scope].cur_page; + + if (unallocated == 0) + { + unallocated = PAGE_SIZE / sizeof (scope_t); + alloc_counts[(int)alloc_type_scope].cur_page = cur_page = allocate_page (); + alloc_counts[(int)alloc_type_scope].total_pages++; + } + + ptr = &cur_page->scope[--unallocated]; + alloc_counts[(int)alloc_type_scope].unallocated = unallocated; + } + +#else + + ptr = (scope_t *) xmalloc (sizeof (scope_t)); + +#endif + + alloc_counts[(int)alloc_type_scope].total_alloc++; + *ptr = initial_scope; + return ptr; +} + +/* Free scoping information. */ + +static void +free_scope (ptr) + scope_t *ptr; +{ + alloc_counts[(int)alloc_type_scope].total_free++; + +#ifndef MALLOC_CHECK + ptr->free = alloc_counts[(int)alloc_type_scope].free_list.f_scope; + alloc_counts[(int)alloc_type_scope].free_list.f_scope = ptr; +#else + free ((PTR) ptr); +#endif +} + +/* Allocate links for pages in a virtual array. */ + +static vlinks_t * +allocate_vlinks () +{ + register vlinks_t *ptr; + static vlinks_t initial_vlinks; + +#ifndef MALLOC_CHECK + + register int unallocated = alloc_counts[(int)alloc_type_vlinks].unallocated; + register page_t *cur_page = alloc_counts[(int)alloc_type_vlinks].cur_page; + + if (unallocated == 0) + { + unallocated = PAGE_SIZE / sizeof (vlinks_t); + alloc_counts[(int)alloc_type_vlinks].cur_page = cur_page = allocate_page (); + alloc_counts[(int)alloc_type_vlinks].total_pages++; + } + + ptr = &cur_page->vlinks[--unallocated]; + alloc_counts[(int)alloc_type_vlinks].unallocated = unallocated; + +#else + + ptr = (vlinks_t *) xmalloc (sizeof (vlinks_t)); + +#endif + + alloc_counts[(int)alloc_type_vlinks].total_alloc++; + *ptr = initial_vlinks; + return ptr; +} + +/* Allocate string hash buckets. */ + +static shash_t * +allocate_shash () +{ + register shash_t *ptr; + static shash_t initial_shash; + +#ifndef MALLOC_CHECK + + register int unallocated = alloc_counts[(int)alloc_type_shash].unallocated; + register page_t *cur_page = alloc_counts[(int)alloc_type_shash].cur_page; + + if (unallocated == 0) + { + unallocated = PAGE_SIZE / sizeof (shash_t); + alloc_counts[(int)alloc_type_shash].cur_page = cur_page = allocate_page (); + alloc_counts[(int)alloc_type_shash].total_pages++; + } + + ptr = &cur_page->shash[--unallocated]; + alloc_counts[(int)alloc_type_shash].unallocated = unallocated; + +#else + + ptr = (shash_t *) xmalloc (sizeof (shash_t)); + +#endif + + alloc_counts[(int)alloc_type_shash].total_alloc++; + *ptr = initial_shash; + return ptr; +} + +/* Allocate type hash buckets. */ + +static thash_t * +allocate_thash () +{ + register thash_t *ptr; + static thash_t initial_thash; + +#ifndef MALLOC_CHECK + + register int unallocated = alloc_counts[(int)alloc_type_thash].unallocated; + register page_t *cur_page = alloc_counts[(int)alloc_type_thash].cur_page; + + if (unallocated == 0) + { + unallocated = PAGE_SIZE / sizeof (thash_t); + alloc_counts[(int)alloc_type_thash].cur_page = cur_page = allocate_page (); + alloc_counts[(int)alloc_type_thash].total_pages++; + } + + ptr = &cur_page->thash[--unallocated]; + alloc_counts[(int)alloc_type_thash].unallocated = unallocated; + +#else + + ptr = (thash_t *) xmalloc (sizeof (thash_t)); + +#endif + + alloc_counts[(int)alloc_type_thash].total_alloc++; + *ptr = initial_thash; + return ptr; +} + +/* Allocate structure, union, or enum tag information. */ + +static tag_t * +allocate_tag () +{ + register tag_t *ptr; + static tag_t initial_tag; + +#ifndef MALLOC_CHECK + + ptr = alloc_counts[(int)alloc_type_tag].free_list.f_tag; + if (ptr != (tag_t *) NULL) + alloc_counts[(int)alloc_type_tag].free_list.f_tag = ptr->free; + else + { + register int unallocated = alloc_counts[(int)alloc_type_tag].unallocated; + register page_t *cur_page = alloc_counts[(int)alloc_type_tag].cur_page; + + if (unallocated == 0) + { + unallocated = PAGE_SIZE / sizeof (tag_t); + alloc_counts[(int)alloc_type_tag].cur_page = cur_page = allocate_page (); + alloc_counts[(int)alloc_type_tag].total_pages++; + } + + ptr = &cur_page->tag[--unallocated]; + alloc_counts[(int)alloc_type_tag].unallocated = unallocated; + } + +#else + + ptr = (tag_t *) xmalloc (sizeof (tag_t)); + +#endif + + alloc_counts[(int)alloc_type_tag].total_alloc++; + *ptr = initial_tag; + return ptr; +} + +/* Free scoping information. */ + +static void +free_tag (ptr) + tag_t *ptr; +{ + alloc_counts[(int)alloc_type_tag].total_free++; + +#ifndef MALLOC_CHECK + ptr->free = alloc_counts[(int)alloc_type_tag].free_list.f_tag; + alloc_counts[(int)alloc_type_tag].free_list.f_tag = ptr; +#else + free ((PTR_T) ptr); +#endif +} + +/* Allocate forward reference to a yet unknown tag. */ + +static forward_t * +allocate_forward () +{ + register forward_t *ptr; + static forward_t initial_forward; + +#ifndef MALLOC_CHECK + + register int unallocated = alloc_counts[(int)alloc_type_forward].unallocated; + register page_t *cur_page = alloc_counts[(int)alloc_type_forward].cur_page; + + if (unallocated == 0) + { + unallocated = PAGE_SIZE / sizeof (forward_t); + alloc_counts[(int)alloc_type_forward].cur_page = cur_page = allocate_page (); + alloc_counts[(int)alloc_type_forward].total_pages++; + } + + ptr = &cur_page->forward[--unallocated]; + alloc_counts[(int)alloc_type_forward].unallocated = unallocated; + +#else + + ptr = (forward_t *) xmalloc (sizeof (forward_t)); + +#endif + + alloc_counts[(int)alloc_type_forward].total_alloc++; + *ptr = initial_forward; + return ptr; +} + +/* Allocate head of type hash list. */ + +static thead_t * +allocate_thead () +{ + register thead_t *ptr; + static thead_t initial_thead; + +#ifndef MALLOC_CHECK + + ptr = alloc_counts[(int)alloc_type_thead].free_list.f_thead; + if (ptr != (thead_t *) NULL) + alloc_counts[ (int)alloc_type_thead ].free_list.f_thead = ptr->free; + else + { + register int unallocated = alloc_counts[(int)alloc_type_thead].unallocated; + register page_t *cur_page = alloc_counts[(int)alloc_type_thead].cur_page; + + if (unallocated == 0) + { + unallocated = PAGE_SIZE / sizeof (thead_t); + alloc_counts[(int)alloc_type_thead].cur_page = cur_page = allocate_page (); + alloc_counts[(int)alloc_type_thead].total_pages++; + } + + ptr = &cur_page->thead[--unallocated]; + alloc_counts[(int)alloc_type_thead].unallocated = unallocated; + } + +#else + + ptr = (thead_t *) xmalloc (sizeof (thead_t)); + +#endif + + alloc_counts[(int)alloc_type_thead].total_alloc++; + *ptr = initial_thead; + return ptr; +} + +/* Free scoping information. */ + +static void +free_thead (ptr) + thead_t *ptr; +{ + alloc_counts[(int)alloc_type_thead].total_free++; + +#ifndef MALLOC_CHECK + ptr->free = (thead_t *) alloc_counts[(int)alloc_type_thead].free_list.f_thead; + alloc_counts[(int)alloc_type_thead].free_list.f_thead = ptr; +#else + free ((PTR_T) ptr); +#endif +} + +static lineno_list_t * +allocate_lineno_list () +{ + register lineno_list_t *ptr; + static lineno_list_t initial_lineno_list; + +#ifndef MALLOC_CHECK + + register int unallocated = alloc_counts[(int)alloc_type_lineno].unallocated; + register page_t *cur_page = alloc_counts[(int)alloc_type_lineno].cur_page; + + if (unallocated == 0) + { + unallocated = PAGE_SIZE / sizeof (lineno_list_t); + alloc_counts[(int)alloc_type_lineno].cur_page = cur_page = allocate_page (); + alloc_counts[(int)alloc_type_lineno].total_pages++; + } + + ptr = &cur_page->lineno[--unallocated]; + alloc_counts[(int)alloc_type_lineno].unallocated = unallocated; + +#else + + ptr = (lineno_list_t *) xmalloc (sizeof (lineno_list_t)); + +#endif + + alloc_counts[(int)alloc_type_lineno].total_alloc++; + *ptr = initial_lineno_list; + return ptr; +} diff --git a/gas/config/tc-mips.c b/gas/config/tc-mips.c new file mode 100644 index 00000000000..f59dca2b000 --- /dev/null +++ b/gas/config/tc-mips.c @@ -0,0 +1,2980 @@ +/* tc-mips.c -- assemble code for a MIPS chip. + Copyright (C) 1993 Free Software Foundation, Inc. + Contributed by the OSF and Ralph Campbell. + Written by Keith Knowles and Ralph Campbell, working independently. + Modified for ECOFF support by Ian Lance Taylor of Cygnus Support. + + This file is part of GAS. + + GAS is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + GAS is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GAS; see the file COPYING. If not, write to + the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include "as.h" + +#include + +#ifndef __STDC__ +#ifndef NO_STDARG +#define NO_STDARG +#endif +#endif + +#ifndef NO_STDARG +#include +#else +#ifndef NO_VARARGS +#include +#endif /* NO_VARARGS */ +#endif /* NO_STDARG */ + +#include "mips-opcode.h" + +#define AT 1 +#define RA 31 + +static int mips_warn_about_macros; +static int mips_noreorder; +static int mips_nomove; +static int mips_noat; +static int mips_nobopt; + +#define N_RMASK 0xc4 +#define N_VFP 0xd4 + +/* handle of the OPCODE hash table */ +static struct hash_control *op_hash = NULL; + +/* This array holds the chars that always start a comment. If the + pre-processor is disabled, these aren't very useful */ +const char comment_chars[] = "#"; + +/* This array holds the chars that only start a comment at the beginning of + a line. If the line seems to have the form '# 123 filename' + .line and .file directives will appear in the pre-processed output */ +/* Note that input_file.c hand checks for '#' at the beginning of the + first line of the input file. This is because the compiler outputs + #NO_APP at the beginning of its output. */ +/* Also note that C style comments are always supported. */ +const char line_comment_chars[] = "#"; + +/* This array holds machine specific line separator characters. */ +const char line_separator_chars[] = ""; + +/* Chars that can be used to separate mant from exp in floating point nums */ +const char EXP_CHARS[] = "eE"; + +/* Chars that mean this number is a floating point constant */ +/* As in 0f12.456 */ +/* or 0d1.2345e12 */ +const char FLT_CHARS[] = "rRsSfFdDxXpP"; + +/* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be + changed in read.c . Ideally it shouldn't have to know about it at all, + but nothing is ideal around here. + */ + +static char *insn_error; + +static int byte_order = BYTE_ORDER; + +static int auto_align = 1; + +/* Prototypes for static functions. */ + +#ifdef __STDC__ +#define internalError() \ + as_fatal ("internal Error, line %d, %s", __LINE__, __FILE__) +#else +#define internalError() as_fatal ("MIPS internal Error"); +#endif + +static void append_insn PARAMS ((struct mips_cl_insn *ip, + expressionS *p, + bfd_reloc_code_real_type r)); +static void macro_build PARAMS ((int *counter, expressionS *ep, + const char *name, const char *fmt, + ...)); +static void macro_build_lui PARAMS ((int *counter, expressionS *ep, + int regnum)); +static void set_at PARAMS ((int *counter, int reg)); +static void set_at_unsigned PARAMS ((int *counter, int reg)); +static void check_absolute_expr PARAMS ((struct mips_cl_insn *ip, + expressionS *expr)); +static void load_register PARAMS ((int *counter, + struct mips_cl_insn *ip, + int reg, expressionS *ep)); +static void macro PARAMS ((struct mips_cl_insn *ip)); +static void mips_ip PARAMS ((char *str, struct mips_cl_insn *ip)); +static int my_getSmallExpression PARAMS ((expressionS *ep, char *str)); +static void my_getExpression PARAMS ((expressionS *ep, char *str)); +static symbolS *get_symbol PARAMS ((void)); +static long get_optional_absolute_expression PARAMS ((void)); +static void s_align PARAMS ((int)); +static void s_change_sec PARAMS ((int)); +static void s_cons PARAMS ((int)); +static void s_err PARAMS ((int)); +static void s_extern PARAMS ((int)); +static void s_float_cons PARAMS ((int)); +static void s_option PARAMS ((int)); +static void s_mipsset PARAMS ((int)); +#ifndef OBJ_ECOFF +static void md_obj_begin PARAMS ((void)); +static void md_obj_end PARAMS ((void)); +static long get_number PARAMS ((void)); +static void s_ent PARAMS ((int)); +static void s_mipsend PARAMS ((int)); +static void s_file PARAMS ((int)); +static void s_frame PARAMS ((int)); +static void s_loc PARAMS ((int)); +static void s_mask PARAMS ((char)); +#endif + +/* Pseudo-op table. + + The following pseudo-ops from the Kane and Heinrich MIPS book + should be defined here, but are currently unsupported: .alias, + .galive, .gjaldef, .gjrlive, .livereg, .noalias. + + The following pseudo-ops from the Kane and Heinrich MIPS book are + specific to the type of debugging information being generated, and + should be defined by the object format: .aent, .begin, .bend, + .bgnb, .end, .endb, .ent, .fmask, .frame, .loc, .mask, .verstamp, + .vreg. + + The following pseudo-ops from the Kane and Heinrich MIPS book are + not MIPS CPU specific, but are also not specific to the object file + format. This file is probably the best place to define them, but + they are not currently supported: .asm0, .endr, .lab, .repeat, + .struct, .weakext. */ + +const pseudo_typeS md_pseudo_table[] = +{ + /* MIPS specific pseudo-ops. */ + { "option", s_option, 0 }, + { "set", s_mipsset, 0 }, + { "rdata", s_change_sec, 'r', }, + { "sdata", s_change_sec, 's', }, + + /* Relatively generic pseudo-ops that happen to be used on MIPS + chips. */ + { "asciiz", stringer, 1 }, + { "bss", s_change_sec, 'b' }, + { "err", s_err, 0 }, + { "half", s_cons, 1 }, + + /* These pseudo-ops are defined in read.c, but must be overridden + here for one reason or another. */ + { "align", s_align, 0 }, + { "byte", s_cons, 0 }, + { "data", s_change_sec, 'd' }, + { "double", s_float_cons, 1 }, + { "extern", s_extern, 0 }, + { "float", s_float_cons, 0 }, + { "text", s_change_sec, 't' }, + { "word", s_cons, 2 }, + +#ifndef OBJ_ECOFF + /* These pseudo-ops should be defined by the object file format. + However, ECOFF is the only format which currently defines them, + so we have versions here for a.out. */ + { "aent", s_ent, 1 }, + { "end", s_mipsend, 0 }, + { "ent", s_ent, 0 }, + { "file", s_file, 0 }, + { "fmask", s_ignore, 'F' }, + { "frame", s_ignore, 0 }, + { "loc", s_ignore, 0 }, + { "mask", s_ignore, 'R' }, + { "verstamp", s_ignore, 0 }, +#endif + + /* Sentinel. */ + { NULL } +}; + +const relax_typeS md_relax_table[] = { + 0 +}; + + +static char *expr_end; + +static expressionS imm_expr; +static expressionS offset_expr; +static bfd_reloc_code_real_type imm_reloc; +static bfd_reloc_code_real_type offset_reloc; + +/* + * This function is called once, at assembler startup time. It should + * set up all the tables, etc. that the MD part of the assembler will need. + */ +void +md_begin() +{ + register char *retval = NULL; + register unsigned int i = 0; + + if ((op_hash = hash_new()) == NULL) { + as_fatal("Virtual memory exhausted"); + } + for (i = 0; i < NUMOPCODES;) { + const char *name = mips_opcodes[i].name; + + retval = hash_insert(op_hash, name, &mips_opcodes[i]); + if (retval != NULL && *retval != '\0') { + fprintf (stderr, "internal error: can't hash `%s': %s\n", + mips_opcodes[i].name, retval); + as_fatal ("Broken assembler. No assembly attempted."); + } + do { + if ((mips_opcodes[i].match & mips_opcodes[i].mask) != + mips_opcodes[i].match) { + fprintf (stderr, "internal error: bad opcode: `%s' \"%s\"\n", + mips_opcodes[i].name, mips_opcodes[i].args); + as_fatal ("Broken assembler. No assembly attempted."); + } + ++i; + } while ((i < NUMOPCODES) && !strcmp(mips_opcodes[i].name, name)); + } + +#ifndef OBJ_ECOFF + md_obj_begin (); +#endif +} + +void +md_end () +{ +#ifndef OBJ_ECOFF + md_obj_end (); +#endif +} + +void +md_assemble(str) + char *str; +{ + struct mips_cl_insn insn; + static int init; + + if (!init) { + /* set the default alignment for the text section (2**2) */ + /* This should go in md_begin but text_section isn't initialized then */ + record_alignment(text_section, 2); + init = 1; + } + + imm_expr.X_seg = absent_section; + offset_expr.X_seg = absent_section; + + mips_ip(str, &insn); + if (insn_error) { + as_bad("%s `%s'", insn_error, str); + return; + } + if (insn.insn_mo->pinfo == INSN_MACRO) { + macro(&insn); + } else { + if (imm_expr.X_seg != absent_section) + append_insn(&insn, &imm_expr, imm_reloc); + else if (offset_expr.X_seg != absent_section) + append_insn(&insn, &offset_expr, offset_reloc); + else + append_insn(&insn, NULL, BFD_RELOC_UNUSED); + } +} + +#define ALIGN_ERR "Attempt to assemble instruction onto non word boundary." +#define ALIGN_ERR2 "GAS doesn't do implicit alignment; use .align directive." + +/* + * append insn + * Output an instruction. + */ +static void +append_insn(ip, address_expr, reloc_type) + struct mips_cl_insn *ip; + expressionS *address_expr; + bfd_reloc_code_real_type reloc_type; +{ + char *f; + + f = frag_more(4); +#if 0 /* This is testing the address of the frag, not the alignment of + the instruction in the current section. */ + if ((int) f & 3) { + as_bad(ALIGN_ERR); + as_bad(ALIGN_ERR2); + } +#endif + if (address_expr != NULL) { + fixS *fixP; + + if (address_expr->X_seg == &bfd_abs_section) { + switch (reloc_type) { + case BFD_RELOC_32: + ip->insn_opcode |= address_expr->X_add_number; + break; + + case BFD_RELOC_LO16: + ip->insn_opcode |= address_expr->X_add_number & 0xffff; + break; + + case BFD_RELOC_MIPS_JMP: + case BFD_RELOC_16_PCREL_S2: + goto need_reloc; + + default: + internalError(); + } + } else { + assert(reloc_type != BFD_RELOC_UNUSED); + need_reloc: + fixP = fix_new(frag_now, f - frag_now->fr_literal, 4, + address_expr->X_add_symbol, + address_expr->X_subtract_symbol, + address_expr->X_add_number, + reloc_type == BFD_RELOC_16_PCREL_S2, + reloc_type); + } + } + md_number_to_chars(f, ip->insn_opcode, 4); + + /* + * Fill all delay slots with nops. + */ + if (!mips_noreorder) { + if (ip->insn_mo->pinfo & ANY_DELAY) { + f = frag_more(4); + md_number_to_chars(f, 0, 4); + }; + + /* One extra nop */ + if (ip->insn_mo->pinfo & INSN_EXTRA_DELAY) { + f = frag_more(4); + md_number_to_chars(f, 0, 4); + } + } +} + +#ifndef NO_STDARG +static void +macro_build (int *counter, + expressionS *ep, + const char *name, + const char *fmt, + ...) +#else /* ! defined (NO_STDARG) */ +static void +macro_build (counter, ep, name, fmt, va_alist) + int *counter; + expressionS *ep; + const char *name; + const char *fmt; + va_dcl +#endif /* ! defined (NO_STDARG) */ +{ + struct mips_cl_insn insn; + bfd_reloc_code_real_type r; + va_list args; + +#ifndef NO_STDARG + va_start(args, fmt); +#else + va_start(args); +#endif + + /* + * If the macro is about to expand into a second instruction, + * print a warning if needed. We need to pass ip as a parameter + * to generate a better warning message here... + */ + if (mips_warn_about_macros && *counter == 1) + as_warn("Macro instruction expanded into multiple instructions"); + + *counter += 1; /* bump instruction counter */ + + r = BFD_RELOC_UNUSED; + insn.insn_mo = (struct mips_opcode *) hash_find(op_hash, name); + assert(insn.insn_mo); + assert(strcmp(name, insn.insn_mo->name) == 0); + + while (strcmp(fmt, insn.insn_mo->args) != 0) { + ++insn.insn_mo; + assert(insn.insn_mo->name); + assert(strcmp(name, insn.insn_mo->name) == 0); + } + assert(insn.insn_mo->pinfo != INSN_MACRO); + insn.insn_opcode = insn.insn_mo->match; + for (;;) { + switch (*fmt++) { + case '\0': + break; + + case ',': + case '(': + case ')': + continue; + + case 't': + case 'w': + insn.insn_opcode |= va_arg(args, int) << 16; + continue; + + case 'c': + case 'T': + case 'W': + insn.insn_opcode |= va_arg(args, int) << 16; + continue; + + case 'd': + insn.insn_opcode |= va_arg(args, int) << 11; + continue; + + case 'V': + case 'S': + insn.insn_opcode |= va_arg(args, int) << 11; + continue; + + case '<': + insn.insn_opcode |= va_arg(args, int) << 6; + continue; + + case 'D': + insn.insn_opcode |= va_arg(args, int) << 6; + continue; + + case 'b': + case 's': + case 'r': + case 'v': + insn.insn_opcode |= va_arg(args, int) << 21; + continue; + + case 'i': + case 'j': + case 'o': + r = BFD_RELOC_LO16; + continue; + + case 'p': + assert(ep != NULL); + /* + * This allows macro() to pass an immediate expression for + * creating short branches without creating a symbol. + * Note that the expression still might come from the assembly + * input, in which case the value is not checked for range nor + * is a relocation entry generated (yuck). + */ + if (ep->X_add_symbol == NULL && ep->X_seg == &bfd_abs_section) { + insn.insn_opcode |= (ep->X_add_number >> 2) & 0xffff; + ep = NULL; + } else + r = BFD_RELOC_16_PCREL_S2; + continue; + + default: + internalError(); + } + break; + } + va_end(args); + assert(r == BFD_RELOC_UNUSED ? ep == NULL : ep != NULL); + append_insn(&insn, ep, r); +} + +/* + * Generate a "lui" instruction. + */ +static void +macro_build_lui (counter, ep, regnum) + int *counter; + expressionS *ep; + int regnum; +{ + expressionS high_expr; + struct mips_cl_insn insn; + bfd_reloc_code_real_type r; + CONST char *name = "lui"; + CONST char *fmt = "t,u"; + + high_expr = *ep; + + if (high_expr.X_seg == &bfd_abs_section) { + /* we can compute the instruction now without a relocation entry */ + if (high_expr.X_add_number & 0x8000) + high_expr.X_add_number += 0x10000; + high_expr.X_add_number = + ((unsigned long) high_expr.X_add_number >> 16) & 0xffff; + r = BFD_RELOC_UNUSED; + } else + r = BFD_RELOC_HI16_S; + + /* + * If the macro is about to expand into a second instruction, + * print a warning if needed. We need to pass ip as a parameter + * to generate a better warning message here... + */ + if (mips_warn_about_macros && *counter == 1) + as_warn("Macro instruction expanded into multiple instructions"); + + *counter += 1; /* bump instruction counter */ + + insn.insn_mo = (struct mips_opcode *) hash_find(op_hash, name); + assert(insn.insn_mo); + assert(strcmp(name, insn.insn_mo->name) == 0); + assert(strcmp(fmt, insn.insn_mo->args) == 0); + + insn.insn_opcode = insn.insn_mo->match | (regnum << 16); + if (r == BFD_RELOC_UNUSED) { + insn.insn_opcode |= high_expr.X_add_number; + append_insn(&insn, NULL, r); + } else + append_insn(&insn, &high_expr, r); +} + +/* set_at() + * Generates code to set the $at register to true (one) + * if reg is less than the immediate expression. + */ +static void +set_at (counter, reg) + int *counter; + int reg; +{ + + switch (imm_expr.X_add_number & 0xffff8000) { + case 0: + case 0xffff8000: + macro_build(counter, &imm_expr, "slti", "t,r,j", AT, reg); + return; + + case 0x8000: + macro_build(counter, &imm_expr, "ori", "t,r,i", AT, 0); + break; + + default: + macro_build_lui(counter, &imm_expr, AT); + if (imm_expr.X_add_number & 0xffff) + macro_build(counter, &imm_expr, "addiu", "t,r,j", AT, AT); + } + macro_build(counter, NULL, "slt", "d,v,t", AT, reg, AT); +} + +/* set_at_unsigned() + * Generates code to set the $at register to true (one) + * if reg is less than the immediate expression. + * Unsigned comparison is perfomed. + */ +static void +set_at_unsigned (counter, reg) + int *counter; + int reg; +{ + + switch (imm_expr.X_add_number & 0xffff8000) { + case 0: + case 0xffff8000: + macro_build(counter, &imm_expr, "sltiu", "t,r,j", AT, reg); + return; + + case 0x8000: + macro_build(counter, &imm_expr, "ori", "t,r,i", AT, 0); + break; + + default: + macro_build_lui(counter, &imm_expr, AT); + if (imm_expr.X_add_number & 0xffff) + macro_build(counter, &imm_expr, "addiu", "t,r,j", AT, AT); + } + macro_build(counter, NULL, "sltu", "d,v,t", AT, reg, AT); +} + +static void +check_absolute_expr (ip, expr) + struct mips_cl_insn *ip; + expressionS *expr; +{ + + if (expr->X_seg != &bfd_abs_section) + as_warn("Instruction %s requires absolute expression", ip->insn_mo->name); +} + +/* load_register() + * This routine generates the least number of instructions neccessary to load + * an absolute expression value into a register. + */ +static void +load_register (counter, ip, reg, ep) + int *counter; + struct mips_cl_insn *ip; + int reg; + expressionS *ep; +{ + switch (ep->X_add_number & 0xffff8000) { + case 0: + case 0xffff8000: + macro_build(counter, ep, "addiu", "t,r,j", reg, 0); + break; + + case 0x8000: + macro_build(counter, ep, "ori", "t,r,i", reg, 0); + break; + + default: + macro_build_lui(counter, ep, reg); + if (ep->X_add_number & 0xffff) + macro_build(counter, ep, "addiu", "t,r,j", reg, reg); + } +} + + +/* + * Build macros + * This routine implements the seemingly endless macro or synthesized + * instructions and addressing modes in the mips assembly language. Many + * of these macros are simple and are similar to each other. These could + * probably be handled by some kind of table or grammer aproach instead of + * this verbose method. Others are not simple macros but are more like + * optimizing code generation. + * One interesting optimization is when several store macros appear + * consecutivly that would load AT with the upper half of the same address. + * The ensuing load upper instructions are ommited. This implies some kind + * of global optimization. We currently only optimize within a single macro. + * For many of the load and store macros if the address is specified as a + * constant expression in the first 64k of memory (ie ld $2,0x4000c) we + * first load register 'at' with zero and use it as the base register. The + * mips assembler simply uses register $zero. Just one tiny optimization + * we're missing. + */ +static void +macro (ip) + struct mips_cl_insn *ip; +{ + register int treg, sreg, dreg, breg; + int tempreg; + int mask; + int icnt = 0; + int used_at; + int save_reorder_condition; + expressionS expr1; + const char *s; + + treg = (ip->insn_opcode >> 16) & 0x1f; + dreg = (ip->insn_opcode >> 11) & 0x1f; + sreg = breg = (ip->insn_opcode >> 21) & 0x1f; + mask = ip->insn_mo->mask; + + expr1.X_seg = &bfd_abs_section; + expr1.X_subtract_symbol = NULL; + expr1.X_add_symbol = NULL; + expr1.X_add_number = 1; + + switch (mask) { + case M_ABS: + case M_ABSU: + /* + Note: mips algorithm requires the move in the delay slot. +
: bgez $a0,0x4001bc + : move v0,$a0 + : sub v0,$zero,$a0 + : nop + */ + + save_reorder_condition = mips_noreorder; + mips_noreorder = 1; + + expr1.X_add_number = 8; + macro_build(&icnt, &expr1, "bgez", "s,p", sreg); + macro_build(&icnt, NULL, "move", "d,s", dreg, sreg, 0); + macro_build(&icnt, NULL, mask == M_ABS ? "sub" : "subu", "d,v,t", + dreg, 0, sreg); + + mips_noreorder = save_reorder_condition; + return; + + case M_ADD_I: + case M_ADDU_I: + switch (imm_expr.X_add_number & 0xffff8000) { + case 0: + case 0xffff8000: + macro_build(&icnt, &imm_expr, + mask == M_ADD_I ? "addi" : "addiu", "t,r,j", treg, sreg); + return; + + case 0x8000: + macro_build(&icnt, &imm_expr, "ori", "t,r,i", AT, 0); + break; + + default: + macro_build_lui(&icnt, &imm_expr, AT); + if (imm_expr.X_add_number & 0xffff) + macro_build(&icnt, &imm_expr, "addiu", "t,r,j", AT, AT); + break; + } + macro_build(&icnt, NULL, + mask == M_ADD_I ? "add" : "addu", "d,v,t", treg, sreg, AT); + break; + + case M_AND_I: + case M_OR_I: + case M_NOR_I: + case M_XOR_I: + switch (imm_expr.X_add_number & 0xffff8000) { + case 0: + case 0x8000: + switch (mask) { + case M_AND_I: + macro_build(&icnt, &imm_expr, "andi", "t,r,i", treg, sreg); + return; + case M_OR_I: + macro_build(&icnt, &imm_expr, "ori", "t,r,i", treg, sreg); + return; + case M_NOR_I: + macro_build(&icnt, &imm_expr, "ori", "t,r,i", treg, sreg); + macro_build(&icnt, &imm_expr, "nor", "d,v,t", treg, treg, 0); + return; + case M_XOR_I: + macro_build(&icnt, &imm_expr, "xori", "t,r,i", treg, sreg); + return; + default: + internalError(); + } + + case 0xffff8000: + macro_build(&icnt, &imm_expr, "addiu", "t,r,j", AT, 0); + break; + + default: + macro_build_lui(&icnt, &imm_expr, AT); + if (imm_expr.X_add_number & 0xffff) + macro_build(&icnt, &imm_expr, "addiu", "t,r,j", AT, AT); + } + switch (mask) { + case M_AND_I: + macro_build(&icnt, NULL, "and", "d,v,t", treg, sreg, AT); + break; + case M_OR_I: + macro_build(&icnt, NULL, "or", "d,v,t", treg, sreg, AT); + break; + case M_NOR_I: + macro_build(&icnt, NULL, "nor", "d,v,t", treg, sreg, AT); + break; + case M_XOR_I: + macro_build(&icnt, NULL, "xor", "d,v,t", treg, sreg, AT); + break; + default: + internalError(); + } + break; + + case M_BEQ_I: + case M_BNE_I: + if (imm_expr.X_add_number == 0) { + macro_build(&icnt, &offset_expr, mask == M_BEQ_I ? "beq" : "bne", + "s,t,p", sreg, 0); + return; + } + load_register(&icnt, ip, AT, &imm_expr); + macro_build(&icnt, &offset_expr, mask == M_BEQ_I ? "beq" : "bne", + "s,t,p", sreg, AT); + break; + + case M_BGE: + if (treg == 0) { + macro_build(&icnt, &offset_expr, "bgez", "s,p", sreg); + return; + } + macro_build(&icnt, NULL, "slt", "d,v,t", AT, sreg, treg); + macro_build(&icnt, &offset_expr, "beq", "s,t,p", AT, 0); + break; + + case M_BGT_I: + imm_expr.X_add_number++; + /* FALLTHROUGH */ + case M_BGE_I: + if (imm_expr.X_add_number == 0) { + macro_build(&icnt, &offset_expr, "bgez", "s,p", sreg); + return; + } + if (imm_expr.X_add_number == 1) { + macro_build(&icnt, &offset_expr, "bgtz", "s,p", sreg); + return; + } + set_at(&icnt, sreg); + macro_build(&icnt, &offset_expr, "beq", "s,t,p", AT, 0); + break; + + case M_BGEU: + if (treg == 0) { + macro_build(&icnt, &offset_expr, "b", "p"); + return; + } + macro_build(&icnt, NULL, "sltu", "d,v,t", AT, sreg, treg); + macro_build(&icnt, &offset_expr, "beq", "s,t,p", AT, 0); + break; + + case M_BGEU_I: + if (imm_expr.X_add_number == 0) { + macro_build(&icnt, &offset_expr, "b", "p"); + return; + } + if (imm_expr.X_add_number == 1) { + macro_build(&icnt, &offset_expr, "bne", "s,t,p", sreg, 0); + return; + } + set_at_unsigned(&icnt, sreg); + macro_build(&icnt, &offset_expr, "beq", "s,t,p", AT, 0); + break; + + case M_BGT: + if (treg == 0) { + macro_build(&icnt, &offset_expr, "bgtz", "s,p", sreg); + return; + } + macro_build(&icnt, NULL, "slt", "d,v,t", AT, treg, sreg); + macro_build(&icnt, &offset_expr, "bne", "s,t,p", AT, 0); + break; + + case M_BGTU: + if (treg == 0) { + macro_build(&icnt, &offset_expr, "bne", "s,t,p", sreg, 0); + return; + } + macro_build(&icnt, NULL, "sltu", "d,v,t", AT, treg, sreg); + macro_build(&icnt, &offset_expr, "bne", "s,t,p", AT, 0); + break; + + case M_BGTU_I: + if (imm_expr.X_add_number == 0) { + macro_build(&icnt, &offset_expr, "bne", "s,t,p", sreg, 0); + return; + } + if (imm_expr.X_add_number == -1) { + /* NOP */ + if (mips_noreorder) + as_warn("Instruction %s is a nop; deleted", ip->insn_mo->name); + return; + } + imm_expr.X_add_number++; + set_at_unsigned(&icnt, sreg); + macro_build(&icnt, &offset_expr, "beq", "s,t,p", AT, 0); + break; + + case M_BLE: + if (treg == 0) { + macro_build(&icnt, &offset_expr, "blez", "s,p", sreg); + return; + } + macro_build(&icnt, NULL, "slt", "d,v,t", AT, treg, sreg); + macro_build(&icnt, &offset_expr, "beq", "s,t,p", AT, 0); + break; + + case M_BLE_I: + if (imm_expr.X_add_number == 0) { + macro_build(&icnt, &offset_expr, "blez", "s,p", sreg); + return; + } + if (imm_expr.X_add_number == -1) { + macro_build(&icnt, &offset_expr, "bltz", "s,p", sreg); + return; + } + imm_expr.X_add_number++; + set_at(&icnt, sreg); + macro_build(&icnt, &offset_expr, "bne", "s,t,p", AT, 0); + break; + + case M_BLEU: + if (treg == 0) { + macro_build(&icnt, &offset_expr, "beq", "s,t,p", sreg, 0); + return; + } + macro_build(&icnt, NULL, "sltu", "d,v,t", AT, treg, sreg); + macro_build(&icnt, &offset_expr, "beq", "s,t,p", AT, 0); + break; + + case M_BLEU_I: + if (imm_expr.X_add_number == 0) { + macro_build(&icnt, &offset_expr, "beq", "s,t,p", sreg, 0); + return; + } + if (imm_expr.X_add_number == -1) { + macro_build(&icnt, &offset_expr, "b", "p"); + return; + } + imm_expr.X_add_number++; + set_at_unsigned(&icnt, sreg); + macro_build(&icnt, &offset_expr, "bne", "s,t,p", AT, 0); + break; + + case M_BLT: + if (treg == 0) { + macro_build(&icnt, &offset_expr, "bltz", "s,p", sreg); + return; + } + macro_build(&icnt, NULL, "slt", "d,v,t", AT, sreg, treg); + macro_build(&icnt, &offset_expr, "bne", "s,t,p", AT, 0); + break; + + case M_BLT_I: + if (imm_expr.X_add_number == 0) { + macro_build(&icnt, &offset_expr, "bltz", "s,p", sreg); + return; + } + if (imm_expr.X_add_number == 1) { + macro_build(&icnt, &offset_expr, "blez", "s,p", sreg); + return; + } + set_at(&icnt, sreg); + macro_build(&icnt, &offset_expr, "bne", "s,t,p", AT, 0); + break; + + case M_BLTU: + if (treg == 0) { + /* NOP */ + if (mips_noreorder) + as_warn("Instruction %s is a nop; deleted", ip->insn_mo->name); + return; + } + macro_build(&icnt, NULL, "sltu", "d,v,t", AT, sreg, treg); + macro_build(&icnt, &offset_expr, "bne", "s,t,p", AT, 0); + break; + + case M_BLTU_I: + if (imm_expr.X_add_number == 0) { + /* NOP */ + if (mips_noreorder) + as_warn("Instruction %s is a nop; deleted", ip->insn_mo->name); + return; + } + if (imm_expr.X_add_number == 1) { + macro_build(&icnt, &offset_expr, "beq", "s,t,p", sreg, 0); + return; + } + set_at_unsigned(&icnt, sreg); + macro_build(&icnt, &offset_expr, "bne", "s,t,p", AT, 0); + break; + + case M_DIV_3: + case M_REM_3: + if (treg == 0) { + as_warn("Divide by zero."); + macro_build(&icnt, NULL, "break", "c", 7); + return; + } + + save_reorder_condition = mips_noreorder; + mips_noreorder = 1; + macro_build(&icnt, NULL, "div", "s,t", sreg, treg); + expr1.X_add_number = 8; + macro_build(&icnt, &expr1, "bne", "s,t,p", treg, 0); + macro_build(&icnt, NULL, "nop", "", 0); + macro_build(&icnt, NULL, "break", "c", 7); + expr1.X_add_number = -1; + macro_build(&icnt, &expr1, "addiu", "t,r,j", AT, 0); + expr1.X_add_number = 16; + macro_build(&icnt, &expr1, "bne", "s,t,p", treg, AT); + expr1.X_add_number = 0x80000000; + macro_build_lui(&icnt, &expr1, AT); + expr1.X_add_number = 8; + macro_build(&icnt, &expr1, "bne", "s,t,p", sreg, AT); + macro_build(&icnt, NULL, "nop", "", 0); + macro_build(&icnt, NULL, "break", "c", 6); + mips_noreorder = save_reorder_condition; + macro_build(&icnt, NULL, mask == M_DIV_3 ? "mflo" : "mfhi", "d", dreg); + /* with reorder on there will be two implicit nop instructions here. */ + break; + + case M_DIV_3I: + case M_DIVU_3I: + case M_REM_3I: + case M_REMU_3I: + if (imm_expr.X_add_number == 0) { + as_warn("Divide by zero."); + macro_build(&icnt, NULL, "break", "c", 7); + return; + } + if (imm_expr.X_add_number == 1) { + if (mask == (int)M_DIV_3I || mask == (int)M_DIVU_3I) + macro_build(&icnt, NULL, "move", "d,s", dreg, sreg); + else + macro_build(&icnt, NULL, "move", "d,s", dreg, 0); + return; + } + + load_register(&icnt, ip, AT, &imm_expr); + if (mask == (int)M_DIV_3I || mask == (int)M_REM_3I) + macro_build(&icnt, NULL, "div", "s,t", sreg, AT); + else + macro_build(&icnt, NULL, "divu", "s,t", sreg, AT); + + if (mask == (int)M_DIV_3I || mask == (int)M_DIVU_3I) + macro_build(&icnt, NULL, "mflo", "d", dreg); + else + macro_build(&icnt, NULL, "mfhi", "d", dreg); + /* two implicit nop's required for mflo or mfhi */ + break; + + case M_DIVU_3: + case M_REMU_3: + save_reorder_condition = mips_noreorder; + mips_noreorder = 1; + macro_build(&icnt, NULL, "divu", "s,t", sreg, treg); + expr1.X_add_number = 8; + macro_build(&icnt, &expr1, "bne", "s,t,p", treg, 0); + macro_build(&icnt, NULL, "nop", "", 0); + macro_build(&icnt, NULL, "break", "c", 7); + mips_noreorder = save_reorder_condition; + macro_build(&icnt, NULL, mask == M_DIVU_3 ? "mflo" : "mfhi", "d", dreg); + /* with reorder on there will be two implicit nop instructions here. */ + return; + + case M_LA: + if (offset_expr.X_seg == &bfd_abs_section) { + load_register(&icnt, ip, treg, &offset_expr); + return; + } + macro_build_lui(&icnt, &offset_expr, treg); + macro_build(&icnt, &offset_expr, "addiu", "t,r,j", treg, treg); + return; + + case M_LA_AB: + tempreg = (breg == treg) ? AT : treg; + if (offset_expr.X_seg == &bfd_abs_section) + load_register(&icnt, ip, tempreg, &offset_expr); + else { + macro_build_lui(&icnt, &offset_expr, tempreg); + macro_build(&icnt, &offset_expr, "addiu", "t,r,j", tempreg, tempreg); + } + if (breg != 0) + macro_build(&icnt, NULL, "addu", "d,v,t", treg, tempreg, breg); + if (breg == treg) + break; + return; + + case M_LB_AB: + s = "lb"; + goto ld; + case M_LBU_AB: + s = "lbu"; + goto ld; + case M_LH_AB: + s = "lh"; + goto ld; + case M_LHU_AB: + s = "lhu"; + goto ld; + case M_LW_AB: + s = "lw"; + goto ld; + case M_LWC0_AB: + s = "lwc0"; + goto ld; + case M_LWC1_AB: + s = "lwc1"; + goto ld; + case M_LWC2_AB: + s = "lwc2"; + goto ld; + case M_LWC3_AB: + s = "lwc3"; + goto ld; + case M_LWL_AB: + s = "lwl"; + goto ld; + case M_LWR_AB: + s = "lwr"; + ld: + if (breg == treg) { + tempreg = AT; + used_at = 1; + } else { + tempreg = treg; + used_at = 0; + } + goto ld_st; + case M_SB_AB: + s = "sb"; + goto st; + case M_SH_AB: + s = "sh"; + goto st; + case M_SW_AB: + s = "sw"; + goto st; + case M_SWC0_AB: + s = "swc0"; + goto st; + case M_SWC1_AB: + s = "swc1"; + goto st; + case M_SWC2_AB: + s = "swc2"; + goto st; + case M_SWC3_AB: + s = "swc3"; + goto st; + case M_SWL_AB: + s = "swl"; + goto st; + case M_SWR_AB: + s = "swr"; + st: + tempreg = AT; + used_at = 1; + ld_st: + macro_build_lui(&icnt, &offset_expr, tempreg); + if (breg != 0) + macro_build(&icnt, NULL, "addu", "d,v,t", tempreg, tempreg, breg); + macro_build(&icnt, &offset_expr, s, + mask == M_LWC1_AB || mask == M_SWC1_AB ? "T,o(b)" : "t,o(b)", + treg, tempreg); + if (used_at) + break; + return; + + case M_LI: + load_register(&icnt, ip, treg, &imm_expr); + return; + + case M_LI_D: + /* + 0x400370
: lui $at,%hi(foo) + 0x400374 : lw $v0,%lo(foo)($at) + 0x400378 : lw $v1,%lo(foo+4)($at) + .data + : + .float 3.133435 + */ + macro_build_lui(&icnt, &offset_expr, AT); + macro_build(&icnt, &offset_expr, "lw", "t,o(b)", treg, AT); + offset_expr.X_add_number = 4; + macro_build(&icnt, &offset_expr, "lw", "t,o(b)", treg+1, AT); + break; + + case M_LI_DD: + /* + 0x4003a0
: lwc1 $f0,-32752($gp) + 0x4003a4 : lwc1 $f1,-32748($gp) + 0x4003a8 : nop + */ + sreg = (ip->insn_opcode >> 11) & 0x1f; /* Fs reg */ + macro_build(&icnt, &offset_expr, "lwc1", "T,o(b)", treg, AT); + offset_expr.X_add_number = 4; + macro_build(&icnt, &offset_expr, "lwc1", "T,o(b)", treg+1, AT); + break; + + case M_L_DOB: + save_reorder_condition = mips_noreorder; + mips_noreorder = 1; + macro_build(&icnt, &offset_expr, "lwc1", "T,o(b)", treg, breg); + /* unecessary implicit nop */ + mips_noreorder = save_reorder_condition; + offset_expr.X_add_number += 4; + macro_build(&icnt, &offset_expr, "lwc1", "T,o(b)", treg+1, breg); + return; + + case M_L_DAB: + /* + * The MIPS assembler seems to check for X_add_number not + * being double aligned and generating: + * lui at,%hi(foo+1) + * addu at,at,v1 + * addiu at,at,%lo(foo+1) + * lwc1 f2,0(at) + * lwc1 f3,4(at) + * But, the resulting address is the same after relocation so why + * generate the extra instruction? + */ + macro_build_lui(&icnt, &offset_expr, AT); + if (breg != 0) + macro_build(&icnt, NULL, "addu", "d,v,t", AT, AT, breg); + save_reorder_condition = mips_noreorder; + mips_noreorder = 1; + macro_build(&icnt, &offset_expr, "lwc1", "T,o(b)", treg, AT); + /* unecessary implicit nop */ + mips_noreorder = save_reorder_condition; + offset_expr.X_add_number += 4; + macro_build(&icnt, &offset_expr, "lwc1", "T,o(b)", treg+1, AT); + break; + + case M_LD_OB: + s = "lw"; + goto sd_ob; + case M_SD_OB: + s = "sw"; + sd_ob: + macro_build(&icnt, &offset_expr, s, "t,o(b)", treg, breg); + offset_expr.X_add_number = 4; + macro_build(&icnt, &offset_expr, s, "t,o(b)", treg+1, breg); + return; + + case M_LD_AB: + s = "lw"; + if (breg == treg) { + tempreg = AT; + used_at = 1; + } else { + tempreg = treg; + used_at = 0; + } + goto sd_ab; + case M_SD_AB: + s = "sw"; + tempreg = AT; + used_at = 1; + sd_ab: + macro_build_lui(&icnt, &offset_expr, tempreg); + if (breg != 0) + macro_build(&icnt, NULL, "addu", "d,v,t", tempreg, tempreg, breg); + macro_build(&icnt, &offset_expr, s, "t,o(b)", treg, tempreg); + offset_expr.X_add_number += 4; + macro_build(&icnt, &offset_expr, s, "t,o(b)", treg+1, tempreg); + if (used_at) + break; + return; + + case M_MUL: + macro_build(&icnt, NULL, "multu", "s,t", sreg, treg); + macro_build(&icnt, NULL, "mflo", "d", dreg); + /* two implicit nop's required for mflo */ + return; + + case M_MUL_I: + /* + * The mips assembler some times generates shifts and adds. + * Im not trying to be that fancy. GCC should do this for us + * anyway. + */ + load_register(&icnt, ip, AT, &imm_expr); + macro_build(&icnt, NULL, "mult", "s,t", sreg, AT); + macro_build(&icnt, NULL, "mflo", "d", dreg); + /* two implicit nop's required for mflo */ + break; + + case M_ROL: + macro_build(&icnt, NULL, "subu", "d,v,t", AT, 0, treg); + macro_build(&icnt, NULL, "srlv", "d,t,s", AT, sreg, AT); + macro_build(&icnt, NULL, "sllv", "d,t,s", dreg, sreg, treg); + macro_build(&icnt, NULL, "or", "d,v,t", dreg, dreg, AT); + break; + + case M_ROL_I: + macro_build(&icnt, NULL, "sll", "d,w,<", AT, sreg, + imm_expr.X_add_number & 0x1f); + macro_build(&icnt, NULL, "srl", "d,w,<", dreg, sreg, + (0 - imm_expr.X_add_number) & 0x1f); + macro_build(&icnt, NULL, "or", "d,v,t", dreg, dreg, AT); + break; + + case M_ROR: + macro_build(&icnt, NULL, "subu", "d,v,t", AT, 0, treg); + macro_build(&icnt, NULL, "sllv", "d,t,s", AT, sreg, AT); + macro_build(&icnt, NULL, "srlv", "d,t,s", dreg, sreg, treg); + macro_build(&icnt, NULL, "or", "d,v,t", dreg, dreg, AT); + break; + + case M_ROR_I: + macro_build(&icnt, NULL, "srl", "d,w,<", AT, sreg, + imm_expr.X_add_number & 0x1f); + macro_build(&icnt, NULL, "sll", "d,w,<", dreg, sreg, + (0 - imm_expr.X_add_number) & 0x1f); + macro_build(&icnt, NULL, "or", "d,v,t", dreg, dreg, AT); + break; + + case M_S_DOB: + macro_build(&icnt, &offset_expr, "swc1", "T,o(b)", treg, breg); + offset_expr.X_add_number += 4; + macro_build(&icnt, &offset_expr, "swc1", "T,o(b)", treg+1, breg); + return; + + case M_S_DAB: + macro_build_lui(&icnt, &offset_expr, AT); + if (breg != 0) + macro_build(&icnt, NULL, "addu", "d,v,t", AT, AT, breg); + macro_build(&icnt, &offset_expr, "swc1", "T,o(b)", treg, AT); + offset_expr.X_add_number += 4; + macro_build(&icnt, &offset_expr, "swc1", "T,o(b)", treg+1, AT); + break; + + case M_SEQ: + if (sreg == 0) + macro_build(&icnt, &expr1, "sltiu", "t,r,j", dreg, treg); + else if (treg == 0) + macro_build(&icnt, &expr1, "sltiu", "t,r,j", dreg, sreg); + else { + macro_build(&icnt, NULL, "xor", "d,v,t", dreg, sreg, treg); + macro_build(&icnt, &expr1, "sltiu", "t,r,j", dreg, dreg); + } + return; + + case M_SEQ_I: + if (imm_expr.X_add_number == 0) { + macro_build(&icnt, &expr1, "sltiu", "t,r,j", dreg, sreg); + return; + } + if (sreg == 0) { + /* result is always false */ + macro_build(&icnt, NULL, "move", "d,s", dreg, 0); + return; + } + switch (imm_expr.X_add_number & 0xffff8000) { + case 0: + case 0x8000: + macro_build(&icnt, &imm_expr, "xori", "t,r,i", dreg, sreg); + used_at = 0; + break; + + case 0xffff8000: + if (imm_expr.X_add_number != -32768) { + imm_expr.X_add_number = -imm_expr.X_add_number; + macro_build(&icnt, &imm_expr, "addiu", "t,r,j", dreg, sreg); + used_at = 0; + break; + } + /* FALLTHROUGH */ + + default: + macro_build_lui(&icnt, &imm_expr, AT); + if (imm_expr.X_add_number & 0xffff) + macro_build(&icnt, &imm_expr, "addiu", "t,r,j", AT, AT); + macro_build(&icnt, NULL, "xor", "d,v,t", dreg, sreg, AT); + used_at = 1; + } + macro_build(&icnt, &expr1, "sltiu", "t,r,j", dreg, dreg); + if (used_at) + break; + return; + + case M_SGE: /* sreg >= treg <==> not (sreg < treg) */ + s = "slt"; + goto sge; + case M_SGEU: + s = "sltu"; + sge: + macro_build(&icnt, NULL, s, "d,v,t", dreg, sreg, treg); + macro_build(&icnt, &expr1, "xori", "t,r,i", dreg, dreg); + return; + + case M_SGE_I: /* sreg >= I <==> not (sreg < I) */ + case M_SGEU_I: + if (imm_expr.X_add_number < 32768 && imm_expr.X_add_number > -32769) { + macro_build(&icnt, &expr1, + mask == M_SGE_I ? "slti" : "sltiu", "t,r,j", dreg, sreg); + used_at = 0; + } else { + load_register(&icnt, ip, AT, &imm_expr); + macro_build(&icnt, NULL, + mask == M_SGE_I ? "slt" : "sltu", "d,v,t", dreg, sreg, AT); + used_at = 1; + } + macro_build(&icnt, &expr1, "xori", "t,r,i", dreg, dreg); + if (used_at) + break; + return; + + case M_SGT: /* sreg > treg <==> treg < sreg */ + s = "slt"; + goto sgt; + case M_SGTU: + s = "sltu"; + sgt: + macro_build(&icnt, NULL, s, "d,v,t", dreg, treg, sreg); + return; + + case M_SGT_I: /* sreg > I <==> I < sreg */ + s = "slt"; + goto sgti; + case M_SGTU_I: + s = "sltu"; + sgti: + load_register(&icnt, ip, AT, &imm_expr); + macro_build(&icnt, NULL, s, "d,v,t", dreg, AT, sreg); + break; + + case M_SLE: /* sreg <= treg <==> treg >= sreg <==> not (treg < sreg) */ + s = "slt"; + goto sle; + case M_SLEU: + s = "sltu"; + sle: + macro_build(&icnt, NULL, s, "d,v,t", dreg, treg, sreg); + macro_build(&icnt, &imm_expr, "xori", "t,r,i", dreg, dreg); + return; + + case M_SLE_I: /* sreg <= I <==> I >= sreg <==> not (I < sreg) */ + s = "slt"; + goto slei; + case M_SLEU_I: + s = "sltu"; + slei: + load_register(&icnt, ip, AT, &imm_expr); + macro_build(&icnt, NULL, s, "d,v,t", dreg, AT, sreg); + macro_build(&icnt, &offset_expr, "xori", "t,r,i", dreg, dreg); + break; + + case M_SLT_I: + if (imm_expr.X_add_number < 32768 && imm_expr.X_add_number > -32769) { + macro_build(&icnt, &imm_expr, "slti", "t,r,j", dreg, sreg); + return; + } + load_register(&icnt, ip, AT, &imm_expr); + macro_build(&icnt, NULL, "slt", "d,v,t", dreg, sreg, AT); + break; + + case M_SLTU_I: + if (imm_expr.X_add_number < 32768 && imm_expr.X_add_number > -32769) { + macro_build(&icnt, &imm_expr, "sltiu", "t,r,j", dreg, sreg); + return; + } + load_register(&icnt, ip, AT, &imm_expr); + macro_build(&icnt, NULL, "sltu", "d,v,t", dreg, sreg, AT); + break; + + case M_SNE: + if (sreg == 0) + macro_build(&icnt, NULL, "sltu", "d,v,t", dreg, 0, treg); + else if (treg == 0) + macro_build(&icnt, NULL, "sltu", "d,v,t", dreg, 0, sreg); + else { + macro_build(&icnt, NULL, "xor", "d,v,t", dreg, sreg, treg); + macro_build(&icnt, NULL, "sltu", "d,v,t", dreg, 0, dreg); + } + return; + + case M_SNE_I: + if (imm_expr.X_add_number == 0) { + macro_build(&icnt, NULL, "sltu", "d,v,t", dreg, 0, sreg); + return; + } + if (sreg == 0) { + /* result is always true */ + macro_build(&icnt, &expr1, "addiu", "t,r,j", dreg, 0); + return; + } + switch (imm_expr.X_add_number & 0xffff8000) { + case 0: + case 0x8000: + macro_build(&icnt, &imm_expr, "xori", "t,r,i", dreg, sreg); + used_at = 0; + break; + + case 0xffff8000: + if (imm_expr.X_add_number != -32768) { + imm_expr.X_add_number = -imm_expr.X_add_number; + macro_build(&icnt, &imm_expr, "addiu", "t,r,j", dreg, sreg); + used_at = 0; + break; + } + /* FALLTHROUGH */ + + default: + macro_build_lui(&icnt, &imm_expr, AT); + if (imm_expr.X_add_number & 0xffff) + macro_build(&icnt, &imm_expr, "addiu", "t,r,j", AT, AT); + macro_build(&icnt, NULL, "xor", "d,v,t", dreg, sreg, AT); + used_at = 1; + } + macro_build(&icnt, NULL, "sltu", "d,v,t", dreg, 0, dreg); + if (used_at) + break; + return; + + case M_SUB_I: + if (imm_expr.X_add_number < 32768 && imm_expr.X_add_number > -32768) { + imm_expr.X_add_number = -imm_expr.X_add_number; + macro_build(&icnt, &imm_expr, "addi", "t,r,j", dreg, sreg); + return; + } + load_register(&icnt, ip, AT, &imm_expr); + macro_build(&icnt, NULL, "sub", "d,v,t", dreg, sreg, AT); + break; + + case M_SUBU_I: + if (imm_expr.X_add_number < 32768 && imm_expr.X_add_number > -32768) { + imm_expr.X_add_number = -imm_expr.X_add_number; + macro_build(&icnt, &imm_expr, "addiu", "t,r,j", dreg, sreg); + return; + } + load_register(&icnt, ip, AT, &imm_expr); + macro_build(&icnt, NULL, "subu", "d,v,t", dreg, sreg, AT); + break; + + case M_TRUNCWD: + case M_TRUNCWS: + sreg = (ip->insn_opcode >> 11) & 0x1f; /* floating reg */ + dreg = (ip->insn_opcode >> 06) & 0x1f; /* floating reg */ + + /* + * Is the double cfc1 instruction a bug in the mips assembler; + * or is there a reason for it? + */ + save_reorder_condition = mips_noreorder; + mips_noreorder = 1; + macro_build(&icnt, NULL, "cfc1", "t,d", treg, 31); + macro_build(&icnt, NULL, "cfc1", "t,d", treg, 31); + macro_build(&icnt, NULL, "nop", ""); + expr1.X_add_number = 3; + macro_build(&icnt, &expr1, "ori", "t,r,i", AT, treg); + expr1.X_add_number = 2; + macro_build(&icnt, &expr1, "xori", "t,r,i", AT, AT); + macro_build(&icnt, NULL, "ctc1", "t,d", AT, 31); + macro_build(&icnt, NULL, "nop", ""); + macro_build(&icnt, NULL, + mask == M_TRUNCWD ? "cvt.w.d" : "cvt.w.s", "D,S", dreg, sreg); + macro_build(&icnt, NULL, "ctc1", "t,d", treg, 31); + macro_build(&icnt, NULL, "nop", ""); + mips_noreorder = save_reorder_condition; + break; + + case M_ULH: + s = "lb"; + goto ulh; + case M_ULHU: + s = "lbu"; + ulh: + /* avoid load delay */ + offset_expr.X_add_number += 1; + macro_build(&icnt, &offset_expr, s, "t,o(b)", treg, breg); + offset_expr.X_add_number -= 1; + macro_build(&icnt, &offset_expr, "lbu", "t,o(b)", AT, breg); + macro_build(&icnt, NULL, "sll", "d,w,<", treg, treg, 8); + macro_build(&icnt,NULL, "or", "d,v,t", treg, treg, AT); + break; + + case M_ULW: + /* does this work on a big endian machine? */ + offset_expr.X_add_number += 3; + macro_build(&icnt, &offset_expr, "lwl", "t,o(b)", treg, breg); + offset_expr.X_add_number -= 3; + macro_build(&icnt, &offset_expr, "lwr", "t,o(b)", treg, breg); + return; + + case M_ULH_A: + case M_ULHU_A: + case M_ULW_A: + if (offset_expr.X_seg == &bfd_abs_section) + load_register(&icnt, ip, AT, &offset_expr); + else { + macro_build_lui(&icnt, &offset_expr, AT); + macro_build(&icnt, &offset_expr, "addiu", "t,r,j", AT, AT); + } + if (mask == M_ULW_A) { + expr1.X_add_number = 3; + macro_build(&icnt, &expr1, "lwl", "t,o(b)", treg, AT); + imm_expr.X_add_number = 0; + macro_build(&icnt, &expr1, "lwr", "t,o(b)", treg, AT); + } else { + macro_build(&icnt, &expr1, + mask == M_ULH_A ? "lb" : "lbu", "t,o(b)", treg, AT); + imm_expr.X_add_number = 0; + macro_build(&icnt, &expr1, "lbu", "t,o(b)", AT, AT); + macro_build(&icnt, NULL, "sll", "d,w,<", treg, treg, 8); + macro_build(&icnt, NULL, "or", "d,v,t", treg, treg, AT); + } + break; + + case M_USH: + macro_build(&icnt, &offset_expr, "sb", "t,o(b)", treg, breg); + macro_build(&icnt, NULL, "srl", "d,w,<", AT, treg, 8); + offset_expr.X_add_number += 1; + macro_build(&icnt, &offset_expr, "sb", "t,o(b)", AT, breg); + break; + + case M_USW: + offset_expr.X_add_number += 3; + macro_build(&icnt, &offset_expr, "swl", "t,o(b)", treg, breg); + offset_expr.X_add_number -= 3; + macro_build(&icnt, &offset_expr, "swr", "t,o(b)", treg, breg); + return; + + case M_USH_A: + case M_USW_A: + if (offset_expr.X_seg == &bfd_abs_section) + load_register(&icnt, ip, AT, &offset_expr); + else { + macro_build_lui(&icnt, &offset_expr, AT); + macro_build(&icnt, &offset_expr, "addiu", "t,r,j", AT, AT); + } + if (mask == M_USW_A) { + expr1.X_add_number = 3; + macro_build(&icnt, &expr1, "swl", "t,o(b)", treg, AT); + expr1.X_add_number = 0; + macro_build(&icnt, &expr1, "swr", "t,o(b)", treg, AT); + } else { + expr1.X_add_number = 0; + macro_build(&icnt, &expr1, "sb", "t,o(b)", treg, AT); + macro_build(&icnt, NULL, "srl", "d,w,<", treg, treg, 8); + expr1.X_add_number = 1; + macro_build(&icnt, &expr1, "sb", "t,o(b)", treg, AT); + expr1.X_add_number = 0; + macro_build(&icnt, &expr1, "lbu", "t,o(b)", AT, AT); + macro_build(&icnt, NULL, "sll", "d,w,<", treg, treg, 8); + macro_build(&icnt, NULL, "or", "d,v,t", treg, treg, AT); + } + break; + + default: + as_bad("Macro %s not implemented yet", ip->insn_mo->name); + } + if (mips_noat) + as_warn("Macro used $at after \".set noat\""); +} + + +/* +This routine assembles an instruction into its binary format. As a side +effect it sets one of the global variables imm_reloc or offset_reloc to the +type of relocation to do if one of the operands is an address expression. +*/ +static void +mips_ip (str, ip) + char *str; + struct mips_cl_insn *ip; +{ + char *s; + const char *args; + char c; + struct mips_opcode *insn; + char *argsStart; + unsigned int regno; + unsigned int lastregno = 0; + char *s_reset; + + insn_error = NULL; + + for (s = str; islower(*s) || (*s >= '0' && *s <= '3') || *s == '.'; ++s) + continue; + switch (*s) { + + case '\0': + break; + + case ' ': + *s++ = '\0'; + break; + + default: + as_warn("Unknown opcode: `%s'", str); + exit(1); + } + if ((insn = (struct mips_opcode *) hash_find(op_hash, str)) == NULL) { + as_warn("`%s' not in hash table.", str); + insn_error = "ERROR: Unrecognized opcode"; + return; + } + argsStart = s; + for (;;) { + assert(strcmp(insn->name, str) == 0); + ip->insn_mo = insn; + ip->insn_opcode = insn->match; + for (args = insn->args; ; ++args) { + if (*s == ' ') + ++s; + switch (*args) { + + case '\0': /* end of args */ + if (*s == '\0') + return; + break; + + case ',': + if (*s++ == *args) + continue; + s--; + switch (*++args) { + case 'r': + case 'v': + ip->insn_opcode |= lastregno << 21; + continue; + + case 'w': + case 'W': + ip->insn_opcode |= lastregno << 16; + continue; + + case 'V': + ip->insn_opcode |= lastregno << 11; + continue; + } + break; + + case '(': + /* handle optional base register. + Either the base register is omitted or + we must have a left paren. */ + /* this is dependent on the next operand specifier + is a 'b' for base register */ + assert(args[1] == 'b'); + if (*s == '\0') + return; + + case ')': /* these must match exactly */ + if (*s++ == *args) + continue; + break; + + case '<': /* must be at least one digit */ + /* + * According to the manual, if the shift amount is greater + * than 31 or less than 0 the the shift amount should be + * mod 32. In reality the mips assembler issues an error. + * We issue a warning and do the mod. + */ + my_getExpression(&imm_expr, s); + check_absolute_expr(ip, &imm_expr); + if ((unsigned long) imm_expr.X_add_number > 31) { + as_warn("Improper shift amount (%d)", + imm_expr.X_add_number); + imm_expr.X_add_number = imm_expr.X_add_number % 32; + } + ip->insn_opcode |= imm_expr.X_add_number << 6; + imm_expr.X_seg = absent_section; + s = expr_end; + continue; + + case 'c': /* break code */ + my_getExpression(&imm_expr, s); + check_absolute_expr(ip, &imm_expr); + if ((unsigned)imm_expr.X_add_number > 1023) + as_warn("Illegal break code (%d)", imm_expr.X_add_number); + ip->insn_opcode |= imm_expr.X_add_number << 16; + imm_expr.X_seg = absent_section; + s = expr_end; + continue; + + case 'b': /* base register */ + case 'd': /* destination register */ + case 's': /* source register */ + case 't': /* target register */ + case 'r': /* both target and source */ + case 'v': /* both dest and source */ + case 'w': /* both dest and target */ + s_reset = s; + if (s[0] == '$') { + if (isdigit(s[1])) { + ++s; + regno = 0; + do { + regno *= 10; + regno += *s - '0'; + ++s; + } while (isdigit(*s)); + } else if (s[1] == 'f' && s[2] == 'p') { + s += 3; + regno = 30; + } else if (s[1] == 's' && s[2] == 'p') { + s += 3; + regno = 29; + } else if (s[1] == 'g' && s[2] == 'p') { + s += 3; + regno = 28; + } else if (s[1] == 'a' && s[2] == 't') { + s += 3; + regno = 1; + } else + goto notreg; + if (regno > 31) + as_bad("Invalid register number (%d)", regno); + if (regno == AT && !mips_noat) + as_warn("Used $at without \".set noat\""); + c = *args; + if (*s == ' ') + s++; + if (args[1] != *s) { + if (c == 'r' || c == 'v' || c == 'w') { + regno = lastregno; + s = s_reset; + args++; + } + } + switch (c) { + case 'r': + case 's': + case 'v': + case 'b': + ip->insn_opcode |= regno << 21; + break; + case 'd': + ip->insn_opcode |= regno << 11; + break; + case 'w': + case 't': + ip->insn_opcode |= regno << 16; + } + lastregno = regno; + continue; + } + notreg: + switch (*args++) { + case 'r': + case 'v': + ip->insn_opcode |= lastregno << 21; + continue; + case 'w': + ip->insn_opcode |= lastregno << 16; + continue; + } + break; + + case 'D': /* floating point destination register */ + case 'S': /* floating point source register */ + case 'T': /* floating point target register */ + case 'V': + case 'W': + s_reset = s; + if (s[0] == '$' && s[1] == 'f' && isdigit(s[2])) { + s += 2; + regno = 0; + do { + regno *= 10; + regno += *s - '0'; + ++s; + } while (isdigit(*s)); + + if (regno > 31) + as_bad("Invalid float register number (%d)", regno); + + if ((regno & 1) && + !(strcmp(str, "mtc1") == 0 || + strcmp(str, "mfc1") == 0 || + strcmp(str, "lwc1") == 0 || + strcmp(str, "swc1") == 0)) + as_warn("Float register should be even, was %d", + regno); + + c = *args; + if (*s == ' ') + s++; + if (args[1] != *s) { + if (c == 'V' || c == 'W') { + regno = lastregno; + s = s_reset; + args++; + } + } + switch (c) { + case 'D': + ip->insn_opcode |= regno << 6; + break; + case 'V': + case 'S': + ip->insn_opcode |= regno << 11; + break; + case 'W': + case 'T': + ip->insn_opcode |= regno << 16; + } + lastregno = regno; + continue; + } + switch (*args++) { + case 'V': + ip->insn_opcode |= lastregno << 11; + continue; + case 'W': + ip->insn_opcode |= lastregno << 16; + continue; + } + break; + + case 'I': + my_getExpression(&imm_expr, s); + check_absolute_expr(ip, &imm_expr); + s = expr_end; + continue; + + case 'A': + my_getExpression(&offset_expr, s); + imm_reloc = BFD_RELOC_32; + s = expr_end; + continue; + + case 'F': + as_bad("Floating point constants only implemented for pseudo ops."); + continue; + + case 'i': /* 16 bit unsigned immediate */ + case 'j': /* 16 bit signed immediate */ + imm_reloc = BFD_RELOC_LO16; + c = my_getSmallExpression(&imm_expr, s); + if (c) { + if (c != 'l') { + if (imm_expr.X_seg == &bfd_abs_section) + imm_expr.X_add_number = + (imm_expr.X_add_number >> 16) & 0xffff; + else if (c == 'h') + imm_reloc = BFD_RELOC_HI16_S; + else + imm_reloc = BFD_RELOC_HI16; + } + } else + check_absolute_expr(ip, &imm_expr); + if (*args == 'i') { + if ((unsigned long) imm_expr.X_add_number > 65535) + as_bad("16 bit expression not in range 0..65535"); + } else { + if (imm_expr.X_add_number < -32768 || + imm_expr.X_add_number > 32767) + as_bad("16 bit expression not in range -32768..32767"); + } + s = expr_end; + continue; + + case 'o': /* 16 bit offset */ + c = my_getSmallExpression(&offset_expr, s); + /* + * If this value won't fit into a 16 bit offset, then + * go find a macro that will generate the 32 bit offset + * code pattern. + */ + if ((offset_expr.X_add_symbol + && offset_expr.X_seg != &bfd_abs_section) + || offset_expr.X_subtract_symbol + || offset_expr.X_add_number > 32767 + || offset_expr.X_add_number < -32768) + break; + + offset_reloc = BFD_RELOC_LO16; + if (c == 'h' || c == 'H') + offset_expr.X_add_number = + (offset_expr.X_add_number >> 16) & 0xffff; + s = expr_end; + continue; + + case 'p': /* pc relative offset */ + offset_reloc = BFD_RELOC_16_PCREL_S2; + my_getExpression(&offset_expr, s); + s = expr_end; + continue; + + case 'u': /* upper 16 bits */ + c = my_getSmallExpression(&imm_expr, s); + if ((unsigned long)imm_expr.X_add_number > 65535) + as_bad("lui expression not in range 0..65535"); + imm_reloc = BFD_RELOC_LO16; + if (c) { + if (c != 'l') { + if (imm_expr.X_seg == &bfd_abs_section) + imm_expr.X_add_number = + (imm_expr.X_add_number >> 16) & 0xffff; + else if (c == 'h') + imm_reloc = BFD_RELOC_HI16_S; + else + imm_reloc = BFD_RELOC_HI16; + } + } + s = expr_end; + continue; + + case 'a': /* 26 bit address */ + my_getExpression(&offset_expr, s); + s = expr_end; + offset_reloc = BFD_RELOC_MIPS_JMP; + continue; + + default: + fprintf(stderr, "bad char = '%c'\n", *args); + internalError(); + } + break; + } + /* Args don't match. */ + if (insn + 1 < &mips_opcodes[NUMOPCODES] && + !strcmp(insn->name, insn[1].name)) { + ++insn; + s = argsStart; + continue; + } + insn_error = "ERROR: Illegal operands"; + return; + } +} + +#define LP '(' +#define RP ')' + +static int +my_getSmallExpression (ep, str) + expressionS *ep; + char *str; +{ + char *sp; + int c = 0; + + if (*str == ' ') + str++; + if (*str == LP + || (*str == '%' && + ((str[1] == 'h' && str[2] == 'i') + || (str[1] == 'H' && str[2] == 'I') + || (str[1] == 'l' && str[2] == 'o')) + && str[3] == LP)) { + if (*str == LP) + c = 0; + else { + c = str[1]; + str += 3; + } + + /* + * A small expression may be followed by a base register. + * Scan to the end of this operand, and then back over a possible + * base register. Then scan the small expression up to that + * point. (Based on code in sparc.c...) + */ + for (sp = str; *sp && *sp != ','; sp++) + ; + if (sp - 4 >= str && sp[-1] == RP) { + if (isdigit(sp[-2])) { + for (sp -= 3; sp >= str && isdigit(*sp); sp--) + ; + if (*sp == '$' && sp > str && sp[-1] == LP) { + sp--; + goto do_it; + } + } else if (sp - 5 >= str + && sp[-5] == LP + && sp[-4] == '$' + && ((sp[-3] == 'f' && sp[-2] == 'p') + || (sp[-3] == 's' && sp[-2] == 'p') + || (sp[-3] == 'g' && sp[-2] == 'p') + || (sp[-3] == 'a' && sp[-2] == 't'))) { + sp -= 5; + do_it: + if (sp == str) { + /* no expression means zero offset */ + if (c) { + /* %xx(reg) is an error */ + ep->X_seg = absent_section; + expr_end = str - 3; + } else { + ep->X_seg = &bfd_abs_section; + expr_end = sp; + } + ep->X_add_symbol = NULL; + ep->X_subtract_symbol = NULL; + ep->X_add_number = 0; + } else { + *sp = '\0'; + my_getExpression(ep, str); + *sp = LP; + } + return c; + } + } + } + my_getExpression(ep, str); + return c; /* => %hi or %lo encountered */ +} + +static void +my_getExpression (ep, str) + expressionS *ep; + char *str; +{ + char *save_in; + asection *seg; + + save_in = input_line_pointer; + input_line_pointer = str; + seg = expression(ep); + expr_end = input_line_pointer; + input_line_pointer = save_in; +} + +char * +md_atof (type,litP,sizeP) + char type; + char *litP; + int *sizeP; +{ + internalError(); + return NULL; +} + +void +md_number_to_chars (buf, val, n) + char *buf; + long val; + int n; +{ + + switch (byte_order) { + case LITTLE_ENDIAN: + switch (n) { + + case 4: + *buf++ = val; + *buf++ = val >> 8; + *buf++ = val >> 16; + *buf = val >> 24; + return; + + case 2: + *buf++ = val; + *buf = val >> 8; + return; + + case 1: + *buf = val; + return; + + default: + internalError(); + } + + case BIG_ENDIAN: + + switch (n) { + + case 4: + *buf++ = val >> 24; + *buf++ = val >> 16; + case 2: + *buf++ = val >> 8; + case 1: + *buf = val; + return; + + default: + internalError(); + } + + default: + internalError(); + } +} + +int +md_parse_option (argP, cntP, vecP) + char **argP; + int *cntP; + char ***vecP; +{ + /* Accept -nocpp but ignore it. */ + if (!strcmp(*argP, "nocpp")) { + *argP += 5; + return 1; + } + return 1; /* pretend you parsed the character */ +} + +long +md_pcrel_from (fixP) + fixS *fixP; +{ + /* return the address of the delay slot */ + return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address; +} + +int +md_apply_fix (fixP, valueP) + fixS *fixP; + long *valueP; +{ + unsigned char *buf; + long insn, value; + + assert(fixP->fx_size == 4); + + value = *valueP; + fixP->fx_addnumber = value; /* Remember value for tc_gen_reloc */ + + switch (fixP->fx_r_type) { + case BFD_RELOC_32: + case BFD_RELOC_MIPS_JMP: + case BFD_RELOC_HI16: + case BFD_RELOC_HI16_S: + case BFD_RELOC_LO16: + /* Nothing needed to do. The value comes from the reloc entry */ + return 1; + + case BFD_RELOC_16_PCREL_S2: + /* + * We need to save the bits in the instruction since fixup_segment() + * might be deleting the relocation entry (i.e., a branch within + * the current segment). + */ + if (value & 0x3) + as_warn("Branch to odd address (%x)", value); + value >>= 2; + if ((value & ~0xFFFF) && (value & ~0xFFFF) != (-1 & ~0xFFFF)) + as_bad("Relocation overflow"); + + /* update old instruction data */ + buf = (unsigned char *)(fixP->fx_where + fixP->fx_frag->fr_literal); + switch (byte_order) { + case LITTLE_ENDIAN: + insn = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0]; + break; + + case BIG_ENDIAN: + insn = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3]; + break; + + default: + internalError(); + return 0; + } + insn |= value & 0xFFFF; + md_number_to_chars(buf, insn, 4); + break; + + default: + internalError(); + } + return 1; +} + +#if 0 +void +printInsn(oc) + unsigned long oc; +{ + const struct mips_opcode *p; + int treg, sreg, dreg, shamt; + short imm; + const char *args; + int i; + + for (i = 0; i < NUMOPCODES; ++i) { + p = &mips_opcodes[i]; + if (((oc & p->mask) == p->match) && (p->pinfo != INSN_MACRO)) { + printf("%08lx %s\t", oc, p->name); + treg = (oc >> 16) & 0x1f; + sreg = (oc >> 21) & 0x1f; + dreg = (oc >> 11) & 0x1f; + shamt = (oc >> 6) & 0x1f; + imm = oc; + for (args = p->args; ; ++args) { + switch (*args) { + + case '\0': + printf("\n"); + break; + + case ',': + case '(': + case ')': + printf("%c", *args); + continue; + + case 'r': + assert(treg == sreg); + printf("$%d,$%d", treg, sreg); + continue; + + case 'd': + printf("$%d", dreg); + continue; + + case 't': + printf("$%d", treg); + continue; + + case 'b': + case 's': + printf("$%d", sreg); + continue; + + case 'a': + printf("0x%08lx", oc & 0x1ffffff); + continue; + + case 'i': + case 'j': + case 'o': + case 'u': + printf("%d", imm); + continue; + + case '<': + printf("$%d", shamt); + continue; + + default: + internalError(); + } + break; + } + return; + } + } + printf("%08lx UNDEFINED\n", oc); +} +#endif + +static symbolS * +get_symbol () +{ + int c; + char *name; + symbolS *p; + + name = input_line_pointer; + c = get_symbol_end(); + p = (symbolS *) symbol_find_or_make(name); + *input_line_pointer = c; + return p; +} + +static long +get_optional_absolute_expression () +{ + expressionS exp; + asection *s; + + s = expression(&exp); + if (!(s == &bfd_abs_section || s == big_section || s == absent_section)) { + as_bad("Bad Absolute Expression."); + } + return exp.X_add_number; +} + +static void +s_align (x) + int x; +{ + register int temp; + register long temp_fill; + long max_alignment = 15; + + /* + + o Note that the assembler pulls down any immediately preceeding label + to the aligned address. + o It's not documented but auto alignment is reinstated by + a .align pseudo instruction. + o Note also that after auto alignment is turned off the mips assembler + issues an error on attempt to assemble an improperly aligned data item. + We don't. + + */ + + temp = get_absolute_expression (); + if (temp > max_alignment) + as_bad("Alignment too large: %d. assumed.", temp = max_alignment); + else if (temp < 0) { + as_warn("Alignment negative: 0 assumed."); + temp = 0; + } + if (*input_line_pointer == ',') { + input_line_pointer ++; + temp_fill = get_absolute_expression (); + } else + temp_fill = 0; + if (temp) { + auto_align = 1; + if (!need_pass_2) + frag_align (temp, (int)temp_fill); + } else { + auto_align = 0; + } + + record_alignment(now_seg, temp); + + demand_empty_rest_of_line(); +} + +static void +s_change_sec (sec) + int sec; +{ + switch (sec) { + case 't': + s_text(); + break; + case 'r': + case 'd': + s_data(); + break; + case 'b': +#ifdef BFD_ASSEMBLER + subseg_set (bss_section, (subsegT) get_absolute_expression ()); +#else + subseg_new (bss_section, (subsegT) get_absolute_expression ()); +#endif + demand_empty_rest_of_line (); + break; + default: + as_bad("Global pointers not supported; recompile -G 0"); + return; + } + auto_align = 1; +} + +static void +s_cons (log_size) + int log_size; +{ + + if (log_size > 0 && auto_align) + frag_align(log_size, 0); + cons(1 << log_size); +} + +static void +s_err (x) + int x; +{ + as_fatal("Encountered `.err', aborting assembly"); +} + +static void +s_extern (x) + int x; +{ + long size; + symbolS *symbolP; + + symbolP = get_symbol(); + if (*input_line_pointer == ',') + input_line_pointer++; + size = get_optional_absolute_expression(); + S_SET_VALUE(symbolP, size); +} + +static void +s_float_cons (is_double) + int is_double; +{ + char *f; + short words[4]; + int error_code, repeat; + extern FLONUM_TYPE generic_floating_point_number; + + if (auto_align) + if (is_double) + frag_align(3, 0); + else + frag_align(2, 0); + + SKIP_WHITESPACE (); + if (! is_end_of_line [(unsigned char) *input_line_pointer]) { + do { + error_code = atof_generic(&input_line_pointer, ".", EXP_CHARS, + &generic_floating_point_number); + if (error_code) { + if (error_code == ERROR_EXPONENT_OVERFLOW) + as_warn("Bad floating-point constant: exponent overflow"); + else + as_warn("Bad floating-point constant: unknown error code=%d.", error_code); + } + + if (is_double) { + gen_to_words((LITTLENUM_TYPE *)words, + 4 /* precision */, + 11 /* exponent_bits */ ); + } else { + gen_to_words((LITTLENUM_TYPE *)words, + 2 /* precision */, + 8 /* exponent_bits */ ); + } + if (*input_line_pointer == ':') { + input_line_pointer++; + repeat = get_absolute_expression(); + } else { + repeat = 1; + } + if (is_double) { + f = frag_more(repeat * 8); + for (;repeat--; f += 8) { + md_number_to_chars(f+6, words[0], 2); + md_number_to_chars(f+4, words[1], 2); + md_number_to_chars(f+2, words[2], 2); + md_number_to_chars(f, words[3], 2); + } + } else { + f = frag_more(repeat * 4); + for (;repeat--; f += 4) { + md_number_to_chars(f+2, words[0], 2); + md_number_to_chars(f, words[1], 2); + } + } + SKIP_WHITESPACE(); + if (*input_line_pointer != ',') break; + input_line_pointer++; + SKIP_WHITESPACE(); + } while (1); + } + demand_empty_rest_of_line(); +} + +static void +s_option (x) + int x; +{ + if (strcmp(input_line_pointer, "O1") != 0 + && strcmp(input_line_pointer, "O2") != 0) + as_warn("Unrecognized option"); + demand_empty_rest_of_line(); +} + +static void +s_mipsset (x) + int x; +{ + char *name = input_line_pointer, ch; + + while (!is_end_of_line[(unsigned char) *input_line_pointer]) + input_line_pointer++; + ch = *input_line_pointer; + *input_line_pointer = '\0'; + + if (strcmp(name, "reorder") == 0) { + mips_noreorder = 0; + } else if (strcmp(name, "noreorder") == 0) { + mips_noreorder = 1; + } else if (strcmp(name, "at") == 0) { + mips_noat = 0; + } else if (strcmp(name, "noat") == 0) { + mips_noat = 1; + } else if (strcmp(name, "macro") == 0) { + mips_warn_about_macros = 0; + } else if (strcmp(name, "nomacro") == 0) { + if (mips_noreorder == 0) + as_bad("`noreorder' must be set before `nomacro'"); + mips_warn_about_macros = 1; + } else if (strcmp(name, "move") == 0 || strcmp(name, "novolatile") == 0) { + mips_nomove = 0; + } else if (strcmp(name, "nomove") == 0 || strcmp(name, "volatile") == 0) { + mips_nomove = 1; + } else if (strcmp(name, "bopt") == 0) { + mips_nobopt = 0; + } else if (strcmp(name, "nobopt") == 0) { + mips_nobopt = 1; + } else { + as_warn("Tried to set unrecognized symbol: %s\n", name); + } + *input_line_pointer = ch; + demand_empty_rest_of_line(); +} + +int +tc_get_register () +{ + int reg; + + SKIP_WHITESPACE (); + if (*input_line_pointer++ != '$') + { + as_warn ("expected `$'"); + return 0; + } + if (isdigit ((unsigned char) *input_line_pointer)) + { + reg = get_absolute_expression (); + if (reg < 0 || reg >= 32) + { + as_warn ("Bad register number"); + reg = 0; + } + } + else + { + if (strncmp (input_line_pointer, "fp", 2) == 0) + reg = 30; + else if (strncmp (input_line_pointer, "sp", 2) == 0) + reg = 29; + else if (strncmp (input_line_pointer, "gp", 2) == 0) + reg = 28; + else if (strncmp (input_line_pointer, "at", 2) == 0) + reg = 1; + else + { + as_warn ("Unrecognized register name"); + return 0; + } + input_line_pointer += 2; + } + return reg; +} + +/* + * Translate internal representation of relocation info to BFD target format. + */ +arelent * +tc_gen_reloc (section, fixp) + asection *section; + fixS *fixp; +{ + arelent *reloc; + + reloc = (arelent *) xmalloc (sizeof (arelent)); + assert (reloc != 0); + + reloc->sym_ptr_ptr = &fixp->fx_addsy->bsym; + reloc->address = fixp->fx_frag->fr_address + fixp->fx_where; + if (fixp->fx_pcrel == 0) + reloc->addend = fixp->fx_addnumber; + else +#ifdef OBJ_ELF + reloc->addend = 0; +#else + reloc->addend = - reloc->address; +#endif + reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type); + assert (reloc->howto != 0); + +#ifdef OBJ_ECOFF + /* FIXME: This does the right thing, but it's confusing. There + should be a more coherent approach, but I don't know what it + would be. */ + reloc->addend -= + bfd_get_section_vma (stdoutput, + bfd_get_section (fixp->fx_addsy->bsym)); +#endif + + return reloc; +} + +/* should never be called */ +long +md_section_align(seg, addr) + asection *seg; + long addr; +{ + int align = bfd_get_section_alignment(stdoutput, seg); + + return ((addr + (1 << align) - 1) & (-1 << align)); +} + +int +md_estimate_size_before_relax(fragP, segtype) + fragS *fragP; + asection *segtype; +{ + as_fatal("md_estimate_size_before_relax"); + return(1); +} /* md_estimate_size_before_relax() */ + +#ifndef OBJ_ECOFF + +/* These functions should really be defined by the object file format, + since they are related to debugging information. However, this + code has to work for the a.out format, which does not define them, + so we provide simple versions here. These don't actually generate + any debugging information, but they do simple checking and someday + somebody may make them useful. */ + +typedef struct loc { + struct loc *loc_next; + unsigned long loc_fileno; + unsigned long loc_lineno; + unsigned long loc_offset; + unsigned short loc_delta; + unsigned short loc_count; +#if 0 + fragS *loc_frag; +#endif +} locS; + +typedef struct proc { + struct proc *proc_next; + struct symbol *proc_isym; + struct symbol *proc_end; + unsigned long proc_reg_mask; + unsigned long proc_reg_offset; + unsigned long proc_fpreg_mask; + unsigned long proc_fpreg_offset; + unsigned long proc_frameoffset; + unsigned long proc_framereg; + unsigned long proc_pcreg; + locS *proc_iline; + struct file *proc_file; + int proc_index; +} procS; + +typedef struct file { + struct file *file_next; + unsigned long file_fileno; + struct symbol *file_symbol; + struct symbol *file_end; + struct proc *file_proc; + int file_numprocs; +} fileS; + +static struct obstack proc_frags; +static procS *proc_lastP; +static procS *proc_rootP; +static int numprocs; + +static void +md_obj_begin () +{ + obstack_begin(&proc_frags, 0x2000); +} + +static void +md_obj_end () +{ + /* check for premature end, nesting errors, etc */ + if (proc_lastP && proc_lastP->proc_end == NULL) + as_warn("missing `.end' at end of assembly"); +} + +extern char hex_value[]; + +static long +get_number () +{ + int negative = 0; + long val = 0; + + if (*input_line_pointer == '-') { + ++input_line_pointer; + negative = 1; + } + if (!isdigit(*input_line_pointer)) + as_bad("Expected simple number."); + if (input_line_pointer[0] == '0') { + if (input_line_pointer[1] == 'x') { + input_line_pointer += 2; + while (isxdigit(*input_line_pointer)) { + val <<= 4; + val |= hex_value[(int) *input_line_pointer++]; + } + return negative ? -val : val; + } else { + ++input_line_pointer; + while (isdigit(*input_line_pointer)) { + val <<= 3; + val |= *input_line_pointer++ - '0'; + } + return negative ? -val : val; + } + } + if (!isdigit(*input_line_pointer)) { + printf(" *input_line_pointer == '%c' 0x%02x\n", + *input_line_pointer, *input_line_pointer); + as_warn("Invalid number"); + return -1; + } + while (isdigit(*input_line_pointer)) { + val *= 10; + val += *input_line_pointer++ - '0'; + } + return negative ? -val : val; +} + +/* The .file directive; just like the usual .file directive, but there + is an initial number which is the ECOFF file index. */ + +static void +s_file (x) + int x; +{ + int line; + + line = get_number(); + s_app_file(); +} + + +/* The .end directive. */ + +static void +s_mipsend (x) + int x; +{ + symbolS *p; + + if (!is_end_of_line[(unsigned char) *input_line_pointer]) { + p = get_symbol(); + demand_empty_rest_of_line(); + } else + p = NULL; + if (now_seg != text_section) + as_warn(".end not in text section"); + if (!proc_lastP) { + as_warn(".end and no .ent seen yet."); + return; + } + + if (p != NULL) { + assert(S_GET_NAME(p)); + if (strcmp(S_GET_NAME(p), S_GET_NAME(proc_lastP->proc_isym))) + as_warn(".end symbol does not match .ent symbol."); + } + + proc_lastP->proc_end = (symbolS *) 1; +} + +/* The .aent and .ent directives. */ + +static void +s_ent (aent) + int aent; +{ + int number = 0; + procS *procP; + symbolS *symbolP; + + symbolP = get_symbol(); + if (*input_line_pointer == ',') + input_line_pointer++; + if (isdigit(*input_line_pointer) || *input_line_pointer == '-') + number = get_number(); + if (now_seg != text_section) + as_warn(".ent or .aent not in text section."); + + if (!aent && proc_lastP && proc_lastP->proc_end == NULL) + as_warn("missing `.end'"); + + if (!aent) { + procP = (procS *) obstack_alloc(&proc_frags, sizeof(*procP)); + procP->proc_isym = symbolP; + procP->proc_reg_mask = 0; + procP->proc_reg_offset = 0; + procP->proc_fpreg_mask = 0; + procP->proc_fpreg_offset = 0; + procP->proc_frameoffset = 0; + procP->proc_framereg = 0; + procP->proc_pcreg = 0; + procP->proc_end = NULL; + procP->proc_next = NULL; + if (proc_lastP) + proc_lastP->proc_next = procP; + else + proc_rootP = procP; + proc_lastP = procP; + numprocs++; + } + demand_empty_rest_of_line(); +} + +/* The .frame directive. */ + +static void +s_frame (x) + int x; +{ +#if 0 + char str[100]; + symbolS *symP; + int frame_reg; + int frame_off; + int pcreg; + + frame_reg = tc_get_register(); + if (*input_line_pointer == ',') + input_line_pointer++; + frame_off = get_optional_absolute_expression(); + if (*input_line_pointer == ',') + input_line_pointer++; + pcreg = tc_get_register(); + + /* bob third eye */ + assert(proc_rootP); + proc_rootP->proc_framereg = frame_reg; + proc_rootP->proc_frameoffset = frame_off; + proc_rootP->proc_pcreg = pcreg; + /* bob macho .frame */ + + /* We don't have to write out a frame stab for unoptimized code. */ + if (!(frame_reg == 30 && frame_off == 0)) { + if (!proc_lastP) + as_warn("No .ent for .frame to use." ); + (void) sprintf(str, "R%d;%d", frame_reg, frame_off ); + symP = symbol_new(str, N_VFP, 0, frag_now ); + S_SET_TYPE(symP, N_RMASK); + S_SET_OTHER(symP, 0); + S_SET_DESC(symP, 0); + symP->sy_forward = proc_lastP->proc_isym; + /* bob perhaps I should have used pseudo set */ + } + demand_empty_rest_of_line(); +#endif +} + +/* The .fmask and .mask directives. */ + +static void +s_mask (reg_type) + char reg_type; +{ +#if 0 + char str[100], *strP; + symbolS *symP; + int i; + unsigned int mask; + int off; + + mask = get_number(); + if (*input_line_pointer == ',') + input_line_pointer++; + off = get_absolute_expression(); + + /* bob only for coff */ + assert(proc_rootP); + if (reg_type == 'F' ) { + proc_rootP->proc_fpreg_mask = mask; + proc_rootP->proc_fpreg_offset = off; + } else { + proc_rootP->proc_reg_mask = mask; + proc_rootP->proc_reg_offset = off; + } + + /* bob macho .mask + .fmask */ + + /* We don't have to write out a mask stab if no saved regs. */ + if (!(mask == 0)) { + if (!proc_lastP) + as_warn("No .ent for .mask to use." ); + strP = str; + for (i=0; i<32; i++ ) { + if (mask%2) { + sprintf(strP, "%c%d,", reg_type, i ); + strP += strlen(strP); + } + mask /= 2; + } + sprintf(strP, ";%d,", off ); + symP = symbol_new(str, N_RMASK, 0, frag_now); + S_SET_TYPE(symP, N_RMASK); + S_SET_OTHER(symP, 0); + S_SET_DESC(symP, 0); + symP->sy_forward = proc_lastP->proc_isym; + /* bob perhaps I should have used pseudo set */ + } +#endif +} + +/* The .loc directive. */ + +static void +s_loc (x) + int x; +{ +#if 0 + symbolS * symbolP; + int lineno; + int addroff; + + assert(now_seg == text_section); + + lineno = get_number(); + addroff = obstack_next_free(&frags) - frag_now->fr_literal; + + symbolP = symbol_new ("", N_SLINE, addroff, frag_now); + S_SET_TYPE(symbolP, N_SLINE); + S_SET_OTHER(symbolP, 0); + S_SET_DESC(symbolP, lineno); + symbolP->sy_segment = now_seg; +#endif +} + +#endif /* ! defined (OBJ_ECOFF) */ + diff --git a/gas/config/z8k.mt b/gas/config/z8k.mt index d6781dd6f4b..2c7971095e8 100644 --- a/gas/config/z8k.mt +++ b/gas/config/z8k.mt @@ -1,3 +1,3 @@ -TARG_CPU_DEPENDENTS=$(srcdir)/../opcodes/z8k.h +TARG_CPU_DEPENDENTS=$(srcdir)/../opcodes/z8k-opc.h LOCAL_LOADLIBES=../bfd/libbfd.a TDEFINES=-DBFD_HEADERS -DMANY_SEGMENTS -DBFD -DSINGLE_QUOTE_STRINGS diff --git a/gas/write.c b/gas/write.c index 0c550b99174..17430b5abf8 100644 --- a/gas/write.c +++ b/gas/write.c @@ -400,40 +400,82 @@ write_contents (abfd, sec, xxx) fixup_segment (seginfo->fix_root, sec); + n = 0; for (i = 0, fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next) - if (fixp->fx_addsy) - { - symbolS *sym = fixp->fx_addsy; - asection *sec = sym->bsym->section; - if (sec == &bfd_und_section - || sec == &bfd_abs_section - || sec == &bfd_com_section) - continue; - if (sym->bsym == sec->symbol) - continue; - /* If the section symbol isn't going to be output, the relocs - at least should still work. If not, figure out what to do - when we run into that case. */ - fixp->fx_offset += S_GET_VALUE (sym); - fixp->fx_addsy = symbol_find (sec->name); - if (!fixp->fx_addsy) - { - fixp->fx_addsy = symbol_make (sec->name); - fixp->fx_addsy->bsym = sec->symbol; - } - } + { + n++; + if (fixp->fx_addsy) + { + symbolS *sym = fixp->fx_addsy; + asection *sec = sym->bsym->section; + if (sec == &bfd_und_section + || sec == &bfd_abs_section + || sec == &bfd_com_section) + continue; + if (sym->bsym == sec->symbol) + continue; + /* If the section symbol isn't going to be output, the relocs + at least should still work. If not, figure out what to do + when we run into that case. */ + fixp->fx_offset += S_GET_VALUE (sym); + fixp->fx_addsy = symbol_find (sec->name); + if (!fixp->fx_addsy) + { + fixp->fx_addsy = symbol_make (sec->name); + fixp->fx_addsy->bsym = sec->symbol; + } + } + } /* Force calculations (size, vma) to get done. */ bfd_set_section_contents (stdoutput, sec, "", 0, 0); /* Set up reloc information as well. */ - n = 0; - for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next) - n++; relocs = (arelent **) bfd_alloc_by_size_t (stdoutput, n * sizeof (arelent *)); - for (frags = seginfo->frchainP->frch_root, fixp = seginfo->fix_root, i = 0; + i = 0; + for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next) + { + arelent *reloc; + extern arelent *tc_gen_reloc (); + char *data; + bfd_reloc_status_type s; + + if (fixp->fx_addsy == 0) + { + /* @@ Need some other flag to indicate which have already + been performed... */ + n--; + continue; + } + reloc = tc_gen_reloc (sec, fixp); + if (!reloc) + { + n--; + continue; + } + data = fixp->fx_frag->fr_literal + fixp->fx_where; + if (fixp->fx_where + 4 + > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset) + abort (); + s = bfd_perform_relocation (stdoutput, reloc, data - reloc->address, + sec, stdoutput); + switch (s) + { + case bfd_reloc_ok: + break; + default: + as_fatal ("bad return from bfd_perform_relocation"); + } + relocs[i++] = reloc; + } + + if (n) + bfd_set_reloc (stdoutput, sec, relocs, n); + + /* Write out the frags. */ + for (frags = seginfo->frchainP->frch_root; frags; frags = frags->fr_next) { @@ -443,44 +485,6 @@ write_contents (abfd, sec, xxx) long count; assert (frags->fr_type == rs_fill); - while (fixp - && fixp->fx_frag == frags) - { - arelent *reloc; - extern arelent *tc_gen_reloc (); - char *data; - static bfd_reloc_status_type s; - - if (fixp->fx_addsy == 0) - { - /* @@ Need some other flag to indicate which have already - been performed... */ - n--; - goto next; - } - reloc = tc_gen_reloc (sec, fixp); - if (!reloc) - { - n--; - goto next; - } - data = frags->fr_literal + fixp->fx_where; - if (fixp->fx_where + 4 > frags->fr_fix + frags->fr_offset) - abort (); - s = bfd_perform_relocation (stdoutput, reloc, data - reloc->address, - sec, stdoutput); - switch (s) - { - case bfd_reloc_ok: - break; - default: - printf ("bad s value\n"); - abort (); - } - relocs[i++] = reloc; - next: - fixp = fixp->fx_next; - } if (frags->fr_fix) { x = bfd_set_section_contents (stdoutput, sec, @@ -502,12 +506,6 @@ write_contents (abfd, sec, xxx) offset += fill_size; } } - /* Did we miss any relocs? */ - if (fixp != 0) - abort (); - - if (n) - bfd_set_reloc (stdoutput, sec, relocs, n); } #endif