standard requires. */
static void
-DEFUN (ieee_write_byte, (abfd, byte),
- bfd * abfd AND
- bfd_byte byte)
+ieee_write_byte (abfd, byte)
+ bfd *abfd;
+ bfd_byte byte;
{
bfd_write ((PTR) & byte, 1, 1, abfd);
}
static void
-DEFUN (ieee_write_twobyte, (abfd, twobyte),
- bfd * abfd AND
- int twobyte)
+ieee_write_twobyte (abfd, twobyte)
+ bfd *abfd;
+ int twobyte;
{
bfd_byte b[2];
b[1] = twobyte & 0xff;
}
static void
-DEFUN (ieee_write_2bytes, (abfd, bytes),
- bfd * abfd AND
- int bytes)
+ieee_write_2bytes (abfd, bytes)
+ bfd *abfd;
+ int bytes;
{
bfd_byte buffer[2];
buffer[0] = bytes >> 8;
}
static void
-DEFUN (ieee_write_int, (abfd, value),
- bfd * abfd AND
- bfd_vma value)
+ieee_write_int (abfd, value)
+ bfd *abfd;
+ bfd_vma value;
{
if (((unsigned) value) <= 127)
{
}
static void
-DEFUN (ieee_write_id, (abfd, id),
- bfd * abfd AND
- CONST char *id)
+ieee_write_id (abfd, id)
+ bfd *abfd;
+ CONST char *id;
{
size_t length = strlen (id);
if (length <= 127)
#define this_byte_and_next(ieee) (*((ieee)->input_p++))
static unsigned short
-DEFUN (read_2bytes, (ieee),
- common_header_type * ieee)
+read_2bytes (ieee)
+ common_header_type *ieee;
{
unsigned char c1 = this_byte_and_next (ieee);
unsigned char c2 = this_byte_and_next (ieee);
}
static void
-DEFUN (bfd_get_string, (ieee, string, length),
- common_header_type * ieee AND
- char *string AND
- size_t length)
+bfd_get_string (ieee, string, length)
+ common_header_type *ieee;
+ char *string;
+ size_t length;
{
size_t i;
for (i = 0; i < length; i++)
}
static char *
-DEFUN (read_id, (ieee),
- common_header_type * ieee)
+read_id (ieee)
+ common_header_type *ieee;
{
size_t length;
char *string;
string = bfd_alloc (ieee->abfd, length + 1);
if (!string)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return NULL;
}
bfd_get_string (ieee, string, length);
}
static void
-DEFUN (ieee_write_expression, (abfd, value, symbol, pcrel, index),
- bfd * abfd AND
- bfd_vma value AND
- asymbol * symbol AND
- boolean pcrel AND
- unsigned int index)
+ieee_write_expression (abfd, value, symbol, pcrel, index)
+ bfd *abfd;
+ bfd_vma value;
+ asymbol *symbol;
+ boolean pcrel;
+ unsigned int index;
{
unsigned int term_count = 0;
writes any integer into the buffer supplied and always takes 5 bytes
*/
static void
-DEFUN (ieee_write_int5, (buffer, value),
- bfd_byte * buffer AND
- bfd_vma value)
+ieee_write_int5 (buffer, value)
+ bfd_byte *buffer;
+ bfd_vma value;
{
buffer[0] = (bfd_byte) ieee_number_repeat_4_enum;
buffer[1] = (value >> 24) & 0xff;
}
static void
-DEFUN (ieee_write_int5_out, (abfd, value),
- bfd * abfd AND
- bfd_vma value)
+ieee_write_int5_out (abfd, value)
+ bfd *abfd;
+ bfd_vma value;
{
bfd_byte b[5];
ieee_write_int5 (b, value);
}
static boolean
-DEFUN (parse_int, (ieee, value_ptr),
- common_header_type * ieee AND
- bfd_vma * value_ptr)
+parse_int (ieee, value_ptr)
+ common_header_type *ieee;
+ bfd_vma *value_ptr;
{
int value = this_byte (ieee);
int result;
}
static int
-DEFUN (parse_i, (ieee, ok),
- common_header_type * ieee AND
- boolean * ok)
+parse_i (ieee, ok)
+ common_header_type *ieee;
+ boolean *ok;
{
bfd_vma x;
*ok = parse_int (ieee, &x);
}
static bfd_vma
-DEFUN (must_parse_int, (ieee),
- common_header_type * ieee)
+must_parse_int (ieee)
+ common_header_type *ieee;
{
bfd_vma result;
BFD_ASSERT (parse_int (ieee, &result) == true);
static void
-DEFUN (parse_expression, (ieee, value, symbol, pcrel, extra, section),
- ieee_data_type * ieee AND
- bfd_vma * value AND
- ieee_symbol_index_type * symbol AND
- boolean * pcrel AND
- unsigned int *extra AND
- asection ** section)
+parse_expression (ieee, value, symbol, pcrel, extra, section)
+ ieee_data_type *ieee;
+ bfd_vma *value;
+ ieee_symbol_index_type *symbol;
+ boolean *pcrel;
+ unsigned int *extra;
+ asection **section;
{
#define POS sp[1]
static char last_type; /* is the index for an X or a D */
static ieee_symbol_type *
-DEFUN (get_symbol, (abfd,
- ieee,
- last_symbol,
- symbol_count,
- pptr,
- max_index,
- this_type
- ),
- bfd * abfd AND
- ieee_data_type * ieee AND
- ieee_symbol_type * last_symbol AND
- unsigned int *symbol_count AND
- ieee_symbol_type *** pptr AND
- unsigned int *max_index AND
- char this_type
+get_symbol (abfd,
+ ieee,
+ last_symbol,
+ symbol_count,
+ pptr,
+ max_index,
+ this_type
)
+ bfd *abfd;
+ ieee_data_type *ieee;
+ ieee_symbol_type *last_symbol;
+ unsigned int *symbol_count;
+ ieee_symbol_type ***pptr;
+ unsigned int *max_index;
+ char this_type
+ ;
{
/* Need a new symbol */
unsigned int new_index = must_parse_int (&(ieee->h));
sizeof (ieee_symbol_type));
if (!new_symbol)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return NULL;
}
}
static void
-DEFUN (ieee_slurp_external_symbols, (abfd),
- bfd * abfd)
+ieee_slurp_external_symbols (abfd)
+ bfd *abfd;
{
ieee_data_type *ieee = IEEE_DATA (abfd);
file_ptr offset = ieee->w.r.external_part;
}
static void
-DEFUN (ieee_slurp_symbol_table, (abfd),
- bfd * abfd)
+ieee_slurp_symbol_table (abfd)
+ bfd *abfd;
{
if (IEEE_DATA (abfd)->read_symbols == false)
{
}
unsigned int
-DEFUN (ieee_get_symtab_upper_bound, (abfd),
- bfd * abfd)
+ieee_get_symtab_upper_bound (abfd)
+ bfd *abfd;
{
ieee_slurp_symbol_table (abfd);
extern bfd_target ieee_vec;
unsigned int
-DEFUN (ieee_get_symtab, (abfd, location),
- bfd * abfd AND
- asymbol ** location)
+ieee_get_symtab (abfd, location)
+ bfd *abfd;
+ asymbol **location;
{
ieee_symbol_type *symp;
static bfd dummy_bfd;
}
static asection *
-DEFUN (get_section_entry, (abfd, ieee, index),
- bfd * abfd AND
- ieee_data_type * ieee AND
- unsigned int index)
+get_section_entry (abfd, ieee, index)
+ bfd *abfd;
+ ieee_data_type *ieee;
+ unsigned int index;
{
if (ieee->section_table[index] == (asection *) NULL)
{
if (!tmp)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return NULL;
}
sprintf (tmp, " fsec%4d", index);
}
static void
-DEFUN (ieee_slurp_sections, (abfd),
- bfd * abfd)
+ieee_slurp_sections (abfd)
+ bfd *abfd;
{
ieee_data_type *ieee = IEEE_DATA (abfd);
file_ptr offset = ieee->w.r.section_part;
*/
bfd_target *
-DEFUN (ieee_archive_p, (abfd),
- bfd * abfd)
+ieee_archive_p (abfd)
+ bfd *abfd;
{
char *library;
boolean loop;
abfd->tdata.ieee_ar_data = (ieee_ar_data_type *) bfd_alloc (abfd, sizeof (ieee_ar_data_type));
if (!abfd->tdata.ieee_ar_data)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return NULL;
}
ieee = IEEE_AR_DATA (abfd);
if (!obstack_begin (&ob, 128))
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return (bfd_target *) NULL;
}
ieee->elements = (ieee_ar_obstack_type *) obstack_finish (&ob);
if (!ieee->elements)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return (bfd_target *) NULL;
}
}
static boolean
-DEFUN (ieee_mkobject, (abfd),
- bfd * abfd)
+ieee_mkobject (abfd)
+ bfd *abfd;
{
abfd->tdata.ieee_data = (ieee_data_type *) bfd_zalloc (abfd, sizeof (ieee_data_type));
return abfd->tdata.ieee_data ? true : false;
}
bfd_target *
-DEFUN (ieee_object_p, (abfd),
- bfd * abfd)
+ieee_object_p (abfd)
+ bfd *abfd;
{
char *processor;
unsigned int part;
+ 50);
if (!IEEE_DATA (abfd)->h.first_byte)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
goto fail;
}
bfd_seek (abfd, (file_ptr) 0, SEEK_SET);
}
void
-DEFUN (ieee_get_symbol_info, (ignore_abfd, symbol, ret),
- bfd * ignore_abfd AND
- asymbol * symbol AND
- symbol_info * ret)
+ieee_get_symbol_info (ignore_abfd, symbol, ret)
+ bfd *ignore_abfd;
+ asymbol *symbol;
+ symbol_info *ret;
{
bfd_symbol_info (symbol, ret);
if (symbol->name[0] == ' ')
}
void
-DEFUN (ieee_print_symbol, (ignore_abfd, afile, symbol, how),
- bfd * ignore_abfd AND
- PTR afile AND
- asymbol * symbol AND
- bfd_print_symbol_type how)
+ieee_print_symbol (ignore_abfd, afile, symbol, how)
+ bfd *ignore_abfd;
+ PTR afile;
+ asymbol *symbol;
+ bfd_print_symbol_type how;
{
FILE *file = (FILE *) afile;
}
static boolean
-DEFUN (do_one, (ieee, current_map, location_ptr, s),
- ieee_data_type * ieee AND
- ieee_per_section_type * current_map AND
- unsigned char *location_ptr AND
- asection * s)
+do_one (ieee, current_map, location_ptr, s)
+ ieee_data_type *ieee;
+ ieee_per_section_type *current_map;
+ unsigned char *location_ptr;
+ asection *s;
{
switch (this_byte (&(ieee->h)))
{
sizeof (ieee_reloc_type));
if (!r)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return false;
}
/* Read in all the section data and relocation stuff too */
static boolean
-DEFUN (ieee_slurp_section_data, (abfd),
- bfd * abfd)
+ieee_slurp_section_data (abfd)
+ bfd *abfd;
{
bfd_byte *location_ptr = (bfd_byte *) NULL;
ieee_data_type *ieee = IEEE_DATA (abfd);
per->data = (bfd_byte *) bfd_alloc (ieee->h.abfd, s->_raw_size);
if (!per->data)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return false;
}
/*SUPPRESS 68*/
}
boolean
-DEFUN (ieee_new_section_hook, (abfd, newsect),
- bfd * abfd AND
- asection * newsect)
+ieee_new_section_hook (abfd, newsect)
+ bfd *abfd;
+ asection *newsect;
{
newsect->used_by_bfd = (PTR)
bfd_alloc (abfd, sizeof (ieee_per_section_type));
if (!newsect->used_by_bfd)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return false;
}
ieee_per_section (newsect)->data = (bfd_byte *) NULL;
}
unsigned int
-DEFUN (ieee_get_reloc_upper_bound, (abfd, asect),
- bfd * abfd AND
- sec_ptr asect)
+ieee_get_reloc_upper_bound (abfd, asect)
+ bfd *abfd;
+ sec_ptr asect;
{
ieee_slurp_section_data (abfd);
return (asect->reloc_count + 1) * sizeof (arelent *);
}
static boolean
-DEFUN (ieee_get_section_contents, (abfd, section, location, offset, count),
- bfd * abfd AND
- sec_ptr section AND
- PTR location AND
- file_ptr offset AND
- bfd_size_type count)
+ieee_get_section_contents (abfd, section, location, offset, count)
+ bfd *abfd;
+ sec_ptr section;
+ PTR location;
+ file_ptr offset;
+ bfd_size_type count;
{
ieee_per_section_type *p = (ieee_per_section_type *) section->used_by_bfd;
ieee_slurp_section_data (abfd);
}
unsigned int
-DEFUN (ieee_canonicalize_reloc, (abfd, section, relptr, symbols),
- bfd * abfd AND
- sec_ptr section AND
- arelent ** relptr AND
- asymbol ** symbols)
+ieee_canonicalize_reloc (abfd, section, relptr, symbols)
+ bfd *abfd;
+ sec_ptr section;
+ arelent **relptr;
+ asymbol **symbols;
{
/* ieee_per_section_type *p = (ieee_per_section_type *) section->used_by_bfd;*/
ieee_reloc_type *src = (ieee_reloc_type *) (section->relocation);
}
static int
-DEFUN (comp, (ap, bp),
- CONST PTR ap AND
- CONST PTR bp)
+comp (ap, bp)
+ CONST PTR ap;
+ CONST PTR bp;
{
arelent *a = *((arelent **) ap);
arelent *b = *((arelent **) bp);
*/
static void
-DEFUN (ieee_write_section_part, (abfd),
- bfd * abfd)
+ieee_write_section_part (abfd)
+ bfd *abfd;
{
ieee_data_type *ieee = IEEE_DATA (abfd);
asection *s;
static boolean
-DEFUN (do_with_relocs, (abfd, s),
- bfd * abfd AND
- asection * s)
+do_with_relocs (abfd, s)
+ bfd *abfd;
+ asection *s;
{
unsigned int relocs_to_go = s->reloc_count;
stream = (unsigned char *) (bfd_alloc (abfd, s->_raw_size));
if (!stream)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return false;
}
memset ((PTR) stream, 0, s->_raw_size);
bytes */
static void
-DEFUN (do_as_repeat, (abfd, s),
- bfd * abfd AND
- asection * s)
+do_as_repeat (abfd, s)
+ bfd *abfd;
+ asection *s;
{
if (s->_raw_size)
{
}
static void
-DEFUN (do_without_relocs, (abfd, s),
- bfd * abfd AND
- asection * s)
+do_without_relocs (abfd, s)
+ bfd *abfd;
+ asection *s;
{
bfd_byte *stream = ieee_per_section (s)->data;
static bfd *output_bfd;
static int output_buffer;
-static void
+static void
fill ()
{
bfd_read ((PTR) input_ptr_start, 1, input_ptr_end - input_ptr_start, input_bfd);
input_ptr = input_ptr_start;
}
-static void
+static void
flush ()
{
bfd_write ((PTR) (output_ptr_start), 1, output_ptr - output_ptr_start, output_bfd);
#define NEXT() { input_ptr++; if (input_ptr == input_ptr_end) fill(); }
#define OUT(x) { *output_ptr++ = (x); if(output_ptr == output_ptr_end) flush(); }
-static void
+static void
write_int (value)
int value;
{
}
}
-static void
+static void
copy_id ()
{
int length = THIS ();
}
#define VAR(x) ((x | 0x80))
-static void
+static void
copy_expression ()
{
int stack[10];
};
static void
-DEFUN (fill_int, (buf),
- struct output_buffer_struct *buf)
+fill_int (buf)
+ struct output_buffer_struct *buf;
{
if (buf->buffer == output_buffer)
{
}
static void
-DEFUN (drop_int, (buf),
- struct output_buffer_struct *buf)
+drop_int (buf)
+ struct output_buffer_struct *buf;
{
int type = THIS ();
int ch;
OUT (0);
}
-static void
+static void
copy_int ()
{
int type = THIS ();
#define INTn(q) copy_int()
#define EXPn(q) copy_expression()
-static void
+static void
f1_record ()
{
int ch;
}
-static void
+static void
f0_record ()
{
/* Attribute record */
ID;
}
-static void
+static void
copy_till_end ()
{
int ch = THIS ();
}
-static void
+static void
f2_record ()
{
NEXT ();
static void block ();
-static void
+static void
f8_record ()
{
int ch;
}
}
-static void
+static void
e2_record ()
{
OUT (0xe2);
EXP;
}
-static void
-DEFUN_VOID (block)
+static void
+block ()
{
int ch;
while (1)
*/
static void
-DEFUN (relocate_debug, (output, input),
- bfd * output AND
- bfd * input)
+relocate_debug (output, input)
+ bfd *output;
+ bfd *input;
{
#define IBS 400
#define OBS 400
*/
static void
-DEFUN (ieee_write_debug_part, (abfd),
- bfd * abfd)
+ieee_write_debug_part (abfd)
+ bfd *abfd;
{
ieee_data_type *ieee = IEEE_DATA (abfd);
bfd_chain_type *chain = ieee->chain_root;
/* write the data in an ieee way */
static void
-DEFUN (ieee_write_data_part, (abfd),
- bfd * abfd)
+ieee_write_data_part (abfd)
+ bfd *abfd;
{
asection *s;
ieee_data_type *ieee = IEEE_DATA (abfd);
static boolean
-DEFUN (init_for_output, (abfd),
- bfd * abfd)
+init_for_output (abfd)
+ bfd *abfd;
{
asection *s;
for (s = abfd->sections; s != (asection *) NULL; s = s->next)
ieee_per_section (s)->data = (bfd_byte *) (bfd_alloc (abfd, s->_raw_size));
if (!ieee_per_section (s)->data)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return false;
}
}
* not a byte image, but a record stream.
*/
boolean
-DEFUN (ieee_set_section_contents, (abfd, section, location, offset, count),
- bfd * abfd AND
- sec_ptr section AND
- PTR location AND
- file_ptr offset AND
- bfd_size_type count)
+ieee_set_section_contents (abfd, section, location, offset, count)
+ bfd *abfd;
+ sec_ptr section;
+ PTR location;
+ file_ptr offset;
+ bfd_size_type count;
{
if (ieee_per_section (section)->data == (bfd_byte *) NULL)
{
values into indexes from the right base.
*/
static void
-DEFUN (ieee_write_external_part, (abfd),
- bfd * abfd)
+ieee_write_external_part (abfd)
+ bfd *abfd;
{
asymbol **q;
ieee_data_type *ieee = IEEE_DATA (abfd);
static
void
-DEFUN (ieee_write_me_part, (abfd),
- bfd * abfd)
+ieee_write_me_part (abfd)
+ bfd *abfd;
{
ieee_data_type *ieee = IEEE_DATA (abfd);
ieee->w.r.trailer_part = bfd_tell (abfd);
}
boolean
-DEFUN (ieee_write_object_contents, (abfd),
- bfd * abfd)
+ieee_write_object_contents (abfd)
+ bfd *abfd;
{
ieee_data_type *ieee = IEEE_DATA (abfd);
unsigned int i;
hold them all plus all the cached symbol entries. */
asymbol *
-DEFUN (ieee_make_empty_symbol, (abfd),
- bfd * abfd)
+ieee_make_empty_symbol (abfd)
+ bfd *abfd;
{
ieee_symbol_type *new =
(ieee_symbol_type *) bfd_zmalloc (sizeof (ieee_symbol_type));
if (!new)
{
- bfd_error = no_error;
+ bfd_set_error (bfd_error_no_error);
return NULL;
}
new->symbol.the_bfd = abfd;
}
static bfd *
-DEFUN (ieee_openr_next_archived_file, (arch, prev),
- bfd * arch AND
- bfd * prev)
+ieee_openr_next_archived_file (arch, prev)
+ bfd *arch;
+ bfd *prev;
{
ieee_ar_data_type *ar = IEEE_AR_DATA (arch);
/* take the next one from the arch state, or reset */
}
else
{
- bfd_error = no_more_archived_files;
+ bfd_set_error (bfd_error_no_more_archived_files);
return (bfd *) NULL;
}
ieee_ar_data_type *ar = abfd->my_archive->tdata.ieee_ar_data;
if (ar == (ieee_ar_data_type *) NULL)
{
- bfd_error = invalid_operation;
+ bfd_set_error (bfd_error_invalid_operation);
return -1;
}
else
}
static int
-DEFUN (ieee_sizeof_headers, (abfd, x),
- bfd * abfd AND
- boolean x)
+ieee_sizeof_headers (abfd, x)
+ bfd *abfd;
+ boolean x;
{
return 0;
}
static void
-DEFUN (ieee_bfd_debug_info_start, (abfd),
- bfd * abfd)
+ieee_bfd_debug_info_start (abfd)
+ bfd *abfd;
{
}
static void
-DEFUN (ieee_bfd_debug_info_end, (abfd),
- bfd * abfd)
+ieee_bfd_debug_info_end (abfd)
+ bfd *abfd;
{
}
be ready to output it at close time
*/
static void
-DEFUN (ieee_bfd_debug_info_accumulate, (abfd, section),
- bfd * abfd AND
- asection * section)
+ieee_bfd_debug_info_accumulate (abfd, section)
+ bfd *abfd;
+ asection *section;
{
ieee_data_type *ieee = IEEE_DATA (section->owner);
ieee_data_type *output_ieee = IEEE_DATA (abfd);
bfd_chain_type *n = (bfd_chain_type *) bfd_alloc (abfd, sizeof (bfd_chain_type));
if (!n)
{
- bfd_error = no_memory;
- abort(); /* FIXME */
+ bfd_set_error (bfd_error_no_memory);
+ abort (); /* FIXME */
}
n->this = section->owner;
n->next = (bfd_chain_type *) NULL;
projects / deliverable / binutils-gdb.git / blobdiff