/*
File: cgsas.c
Author: John van Groningen
Machine: Sun 4
At: University of Nijmegen
*/
#include <stdio.h>
#include <string.h>
#define ELF_TARGET_SPARC
#include <elf.h>
#define ELF
#include "cgport.h"
#include "cgrconst.h"
#include "cgtypes.h"
#include "cg.h"
#include "cgiconst.h"
#include "cgcode.h"
#include "cgswas.h"
#define for_l(v,l,n) for(v=(l);v!=NULL;v=v->n)
#define U4(s,v1,v2,v3,v4) s->v1;s->v2;s->v3;s->v4
#define U5(s,v1,v2,v3,v4,v5) s->v1;s->v2;s->v3;s->v4;s->v5
#define IO_BUFFER_SIZE 16384
#define BUFFER_SIZE 4096
struct object_buffer {
struct object_buffer * next;
int size;
unsigned char data [BUFFER_SIZE];
};
#define BRANCH_RELOCATION 0
#define CALL_RELOCATION 1
#define LONG_WORD_RELOCATION 2
#define HI22_RELOCATION 3
#define LO12_RELOCATION 4
#ifdef FUNCTION_LEVEL_LINKING
# define DUMMY_BRANCH_RELOCATION 5
#endif
#ifdef FUNCTION_LEVEL_LINKING
# define TEXT_LABEL_ID (0x7fff-2)
# define DATA_LABEL_ID (0x7fff-3)
#else
# define TEXT_LABEL_ID 1
# define DATA_LABEL_ID 2
#endif
#define CODE_CONTROL_SECTION 0
#define DATA_CONTROL_SECTION 1
#define IMPORTED_LABEL 2
#define EXPORTED_CODE_LABEL 3
#define EXPORTED_DATA_LABEL 4
struct object_label {
struct object_label * next;
union {
unsigned long offset; /* CODE_CONTROL_SECTION,DATA_CONTROL_SECTION */
struct label * label; /* IMPORTED_LABEL,EXPORTED_CODE_LABEL */
} object_label_u1;
union {
unsigned long length; /* CODE_CONTROL_SECTION,DATA_CONTROL_SECTION */
unsigned long string_offset; /* IMPORTED_LABEL,EXPORTED_CODE_LABEL */
} object_label_u2;
int object_label_number;
#ifdef FUNCTION_LEVEL_LINKING
int object_label_n_relocations; /* CODE_CONTROL_SECTION,DATA_CONTROL_SECTION */
short object_label_section_n; /* CODE_CONTROL_SECTION,DATA_CONTROL_SECTION */
#endif
unsigned char object_label_kind;
unsigned char object_section_align8;
};
#define object_label_offset object_label_u1.offset
#define object_label_label object_label_u1.label
#define object_label_length object_label_u2.length
#define object_label_string_offset object_label_u2.string_offset
struct relocation {
struct relocation * next;
unsigned long relocation_offset;
struct label * relocation_label;
long relocation_addend;
#ifdef FUNCTION_LEVEL_LINKING
struct object_label * relocation_object_label; /* for BRANCH_RELOCATION, CALL_RELOCATION and DUMMY_BRANCH_RELOCATION */
#endif
short relocation_kind;
};
static FILE *output_file;
static int n_code_relocations,n_data_relocations;
static struct object_label *code_object_label,*data_object_label;
static struct relocation *first_code_relocation,**last_code_relocation_l;
static struct relocation *first_data_relocation,**last_data_relocation_l;
static struct object_buffer *first_code_buffer,*current_code_buffer;
static int code_buffer_free,code_buffer_offset;
static unsigned int *code_buffer_p;
static struct object_buffer *first_data_buffer,*current_data_buffer;
static int data_buffer_free,data_buffer_offset;
static unsigned int *data_buffer_p;
static void initialize_buffers (void)
{
struct object_buffer *new_code_buffer,*new_data_buffer;
new_code_buffer=memory_allocate_type (struct object_buffer);
new_code_buffer->size=0;
new_code_buffer->next=NULL;
first_code_buffer=new_code_buffer;
current_code_buffer=new_code_buffer;
code_buffer_offset=0;
code_buffer_free=BUFFER_SIZE;
code_buffer_p=(unsigned int*)new_code_buffer->data;
new_data_buffer=memory_allocate_type (struct object_buffer);
new_data_buffer->size=0;
new_data_buffer->next=NULL;
first_data_buffer=new_data_buffer;
current_data_buffer=new_data_buffer;
data_buffer_offset=0;
data_buffer_free=BUFFER_SIZE;
data_buffer_p=(unsigned int*)new_data_buffer->data;
}
static void store_instruction2 (int c)
{
struct object_buffer *new_buffer;
current_code_buffer->size=BUFFER_SIZE;
new_buffer=memory_allocate_type (struct object_buffer);
new_buffer->size=0;
new_buffer->next=NULL;
current_code_buffer->next=new_buffer;
current_code_buffer=new_buffer;
code_buffer_offset+=BUFFER_SIZE;
code_buffer_free=BUFFER_SIZE-4;
code_buffer_p=(unsigned int*)new_buffer->data;
*code_buffer_p++=c;
}
static void store_instruction (int c)
{
if (code_buffer_free>=4){
code_buffer_free-=4;
*code_buffer_p++=c;
} else
store_instruction2 (c);
}
static void store_long_word_in_data_section2 (ULONG c)
{
struct object_buffer *new_buffer;
current_data_buffer->size=BUFFER_SIZE;
new_buffer=memory_allocate_type (struct object_buffer);
new_buffer->size=0;
new_buffer->next=NULL;
current_data_buffer->next=new_buffer;
current_data_buffer=new_buffer;
data_buffer_offset+=BUFFER_SIZE;
data_buffer_free=BUFFER_SIZE-4;
data_buffer_p=(unsigned int*)new_buffer->data;
*data_buffer_p++=c;
}
void store_long_word_in_data_section (ULONG c)
{
if (data_buffer_free>=4){
data_buffer_free-=4;
*data_buffer_p++=c;
} else
store_long_word_in_data_section2 (c);
}
void store_2_words_in_data_section (UWORD w1,UWORD w2)
{
store_long_word_in_data_section ((w1<<16) | ((UWORD)w2));
}
static void flush_code_buffer (void)
{
current_code_buffer->size=BUFFER_SIZE-code_buffer_free;
code_buffer_offset+=BUFFER_SIZE-code_buffer_free;
}
static void flush_data_buffer (void)
{
current_data_buffer->size=BUFFER_SIZE-data_buffer_free;
data_buffer_offset+=BUFFER_SIZE-data_buffer_free;
}
static void write_buffers_and_release_memory (struct object_buffer **first_buffer_l)
{
struct object_buffer *buffer,*next_buffer;
for (buffer=*first_buffer_l; buffer!=NULL; buffer=next_buffer){
int size;
size=buffer->size;
if (fwrite (buffer->data,1,size,output_file)!=size)
error ("Write error");
next_buffer=buffer->next;
memory_free (buffer);
}
*first_buffer_l=NULL;
}
void store_abc_string_in_data_section (char *string,int length)
{
unsigned char *string_p;
string_p=(unsigned char*)string;
store_long_word_in_data_section (length);
while (length>=4){
store_long_word_in_data_section (*(ULONG*)string_p);
string_p+=4;
length-=4;
}
if (length>0){
ULONG d;
int shift;
d=0;
shift=24;
while (length>0){
d |= string_p[0]<<shift;
shift-=8;
--length;
++string_p;
}
store_long_word_in_data_section (d);
}
}
void store_c_string_in_data_section (char *string,int length)
{
unsigned char *string_p;
ULONG d;
int shift;
string_p=(unsigned char*)string;
while (length>=4){
store_long_word_in_data_section (*(ULONG*)string_p);
string_p+=4;
length-=4;
}
d=0;
shift=24;
while (length>0){
d |= string_p[0]<<shift;
shift-=8;
--length;
++string_p;
}
store_long_word_in_data_section (d);
}
#define CURRENT_CODE_OFFSET (code_buffer_offset+((unsigned char*)code_buffer_p-current_code_buffer->data))
#define CURRENT_DATA_OFFSET (data_buffer_offset+((unsigned char*)data_buffer_p-current_data_buffer->data))
static struct object_label *first_object_label,**last_object_label_l;
#ifdef FUNCTION_LEVEL_LINKING
static int n_code_sections,n_data_sections;
#endif
#ifdef FUNCTION_LEVEL_LINKING
void as_new_data_module (void)
{
struct object_label *new_object_label;
unsigned long current_data_offset;
int data_section_label_number;
new_object_label=fast_memory_allocate_type (struct object_label);
data_object_label=new_object_label;
data_section_label_number=0;
current_data_offset=CURRENT_DATA_OFFSET;
*last_object_label_l=new_object_label;
last_object_label_l=&new_object_label->next;
new_object_label->next=NULL;
new_object_label->object_label_offset=current_data_offset;
new_object_label->object_label_number=data_section_label_number;
new_object_label->object_label_section_n=n_data_sections;
++n_data_sections;
new_object_label->object_label_length=0;
new_object_label->object_label_kind=DATA_CONTROL_SECTION;
new_object_label->object_section_align8=0;
}
static void as_new_code_module (void)
{
struct object_label *new_object_label;
unsigned long current_code_offset;
int code_section_label_number;
new_object_label=fast_memory_allocate_type (struct object_label);
code_object_label=new_object_label;
code_section_label_number=0;
current_code_offset=CURRENT_CODE_OFFSET;
*last_object_label_l=new_object_label;
last_object_label_l=&new_object_label->next;
new_object_label->next=NULL;
new_object_label->object_label_offset=current_code_offset;
new_object_label->object_label_number=code_section_label_number;
new_object_label->object_label_section_n=n_code_sections;
++n_code_sections;
new_object_label->object_label_length=0;
new_object_label->object_label_kind=CODE_CONTROL_SECTION;
}
#endif
static void store_label_plus_offset_in_data_section (LABEL *label,int offset)
{
struct relocation *new_relocation;
store_long_word_in_data_section (0);
new_relocation=fast_memory_allocate_type (struct relocation);
++n_data_relocations;
*last_data_relocation_l=new_relocation;
last_data_relocation_l=&new_relocation->next;
new_relocation->next=NULL;
new_relocation->relocation_label=label;
new_relocation->relocation_offset=CURRENT_DATA_OFFSET-4;
new_relocation->relocation_kind=LONG_WORD_RELOCATION;
new_relocation->relocation_addend=offset;
}
static int n_object_labels;
static unsigned long string_table_offset;
void define_data_label (LABEL *label)
{
label->label_id=DATA_LABEL_ID;
#ifdef FUNCTION_LEVEL_LINKING
label->label_object_label=data_object_label;
#endif
label->label_offset=CURRENT_DATA_OFFSET;
if (label->label_flags & EXPORT_LABEL){
struct object_label *new_object_label;
int string_length;
new_object_label=fast_memory_allocate_type (struct object_label);
*last_object_label_l=new_object_label;
last_object_label_l=&new_object_label->next;
new_object_label->next=NULL;
new_object_label->object_label_label=label;
#if defined (RELOCATIONS_RELATIVE_TO_EXPORTED_DATA_LABEL) && defined (FUNCTION_LEVEL_LINKING)
new_object_label->object_label_number = n_object_labels;
#endif
++n_object_labels;
string_length=strlen (label->label_name);
new_object_label->object_label_string_offset=string_table_offset;
string_table_offset+=string_length+1;
#if defined (RELOCATIONS_RELATIVE_TO_EXPORTED_DATA_LABEL) && defined (FUNCTION_LEVEL_LINKING)
label->label_object_label=new_object_label;
new_object_label->object_label_section_n = data_object_label->object_label_section_n;
#endif
new_object_label->object_label_kind=EXPORTED_DATA_LABEL;
}
}
static void as_labels (struct block_label *labels)
{
for (; labels!=NULL; labels=labels->block_label_next)
#if 0
if (labels->block_label_label->label_number==0)
#endif
{
LABEL *label;
label=labels->block_label_label;
label->label_id=TEXT_LABEL_ID;
#ifdef FUNCTION_LEVEL_LINKING
label->label_object_label=code_object_label;
#endif
label->label_offset=CURRENT_CODE_OFFSET;
if (label->label_flags & EXPORT_LABEL){
struct object_label *new_object_label;
int string_length;
new_object_label=fast_memory_allocate_type (struct object_label);
*last_object_label_l=new_object_label;
last_object_label_l=&new_object_label->next;
new_object_label->next=NULL;
new_object_label->object_label_label=label;
new_object_label->object_label_number=n_object_labels;
++n_object_labels;
string_length=strlen (label->label_name);
new_object_label->object_label_string_offset=string_table_offset;
string_table_offset+=string_length+1;
new_object_label->object_label_kind=EXPORTED_CODE_LABEL;
}
}
}
void store_label_in_data_section (LABEL *label)
{
store_label_plus_offset_in_data_section (label,0);
}
void store_descriptor_in_data_section (LABEL *label)
{
store_label_plus_offset_in_data_section (label,2);
}
void store_descriptor_string_in_data_section (char *string,int length,LABEL *string_label)
{
define_data_label (string_label);
store_abc_string_in_data_section (string,length);
}
static void as_branch_label (struct label *label,int relocation_kind)
{
struct relocation *new_relocation;
new_relocation=fast_memory_allocate_type (struct relocation);
++n_code_relocations;
*last_code_relocation_l=new_relocation;
last_code_relocation_l=&new_relocation->next;
new_relocation->next=NULL;
new_relocation->relocation_label=label;
new_relocation->relocation_offset=CURRENT_CODE_OFFSET-4;
#ifdef FUNCTION_LEVEL_LINKING
new_relocation->relocation_object_label=code_object_label;
#endif
new_relocation->relocation_kind=relocation_kind;
new_relocation->relocation_addend=0;
}
static void as_hi_or_lo_label (struct label *label,int offset,int relocation_kind)
{
struct relocation *new_relocation;
new_relocation=fast_memory_allocate_type (struct relocation);
++n_code_relocations;
*last_code_relocation_l=new_relocation;
last_code_relocation_l=&new_relocation->next;
new_relocation->next=NULL;
new_relocation->relocation_label=label;
new_relocation->relocation_offset=CURRENT_CODE_OFFSET-4;
new_relocation->relocation_kind=relocation_kind;
new_relocation->relocation_addend=offset;
}
static void store_label_in_code_section (struct label *label)
{
struct toc_label *t_label;
struct relocation *new_relocation;
store_instruction (0);
new_relocation=fast_memory_allocate_type (struct relocation);
++n_code_relocations;
*last_code_relocation_l=new_relocation;
last_code_relocation_l=&new_relocation->next;
new_relocation->next=NULL;
new_relocation->relocation_offset=CURRENT_CODE_OFFSET-4;
new_relocation->relocation_label=label;
new_relocation->relocation_kind=LONG_WORD_RELOCATION;
new_relocation->relocation_addend=0;
}
#define REGISTER_G0 (-16)
#define REGISTER_I6 (-10)
#define REGISTER_O0 8
#define REGISTER_O1 9
#define REGISTER_O7 15
/*
static char register_type [32]="ggggggiiggiiiiiilllllllloooooooo";
static char register_number[32]="01234767565432100123456701234567";
*/
static unsigned char real_reg_num [32] =
{
0,1,2,3,4,7,30,31,
5,6,29,28,27,26,25,24,
16,17,18,19,20,21,22,23,
8,9,10,11,12,13,14,15
};
#define reg_num(r) (real_reg_num[(r)+16])
#define as_i_id0(i,rd) store_instruction(0x1000000|(reg_num(rd)<<25)|((i)&0x3fffff))
#define as_i_bic(i,cond) store_instruction((cond<<25)|(2<<22)|((i)&0x3fffffff))
#define as_i_bica(i,cond) store_instruction((1<<29)|(cond<<25)|(2<<22)|(i)&0x3fffffff)
#define as_i_call(i) store_instruction((1<<30)|i)
#define as_i_fbic(i,cond) store_instruction((cond<<25)|(6<<22)|i)
#define as_i_fbica(i,cond) store_instruction((1<<29)|(cond<<25)|(6<<22)|i)
#define as_i_abd2(ra,rb,rd,op) store_instruction(0x80000000|((op)<<19)|(reg_num(rd)<<25)|(reg_num(ra)<<14)|reg_num(rb))
#define as_i_fb2(fa,fb,op,opf) store_instruction(0x80000000|((op)<<19)|((fa)<<14)|((opf)<<5)|(fb))
#define as_i_ff2(ra,rd,op,opf) store_instruction(0x80000000|((op)<<19)|((rd)<<25)|((opf)<<5)|(ra))
#define as_i_fff2(ra,rb,rd,op,opf) store_instruction(0x80000000|((op)<<19)|((rd)<<25)|((ra)<<14)|((opf)<<5)|(rb))
#define as_i_aid2(ra,i,rd,op) store_instruction(0x80000000|((op)<<19)|(reg_num(rd)<<25)|(reg_num(ra)<<14)|0x2000|((i)&0x1fff))
#define as_i_abd3(ra,rb,rd,op) store_instruction(0xc0000000|((op)<<19)|(reg_num(rd)<<25)|(reg_num(ra)<<14)|reg_num(rb))
#define as_i_aod3(ra,o,rd,op) store_instruction(0xc0000000|((op)<<19)|(reg_num(rd)<<25)|(reg_num(ra)<<14)|0x2000|((o)&0x1fff))
#define as_i_foa3(fa,o,ra,op) store_instruction(0xc0000000|((op)<<19)|((fa)<<25)|((reg_num(ra))<<14)|0x2000|((o)&0x1fff))
#define as_i_fab3(fa,ra,rb,op) store_instruction(0xc0000000|((op)<<19)|((fa)<<25)|((reg_num(ra))<<14)|(rb))
#define LD_OP 0
#define LDUB_OP 1
#define LDUH_OP 2
#define LDSB_OP 9
#define LDSH_OP 10
#define ST_OP 4
#define STB_OP 5
#define STH_OP 6
#define LDF_OP 0x20
#define LDDF_OP 0x23
#define STF_OP 0x24
#define AND_OP 1
#define OR_OP 2
#define XOR_OP 3
#define SLL_OP 0x25
#define SRL_OP 0x26
#define SRA_OP 0x27
#define FADDD_OP 0x42
#define FDIVD_OP 0x4e
#define FMULD_OP 0x4a
#define FSUBD_OP 0x46
#define A_COND 0x8
#define E_COND 0x1
#define GE_COND 0xb
#define G_COND 0xa
#define L_COND 0x3
#define LE_COND 0x2
#define NE_COND 0x9
#define CS_COND 0x5
#define VC_COND 0xf
#define VS_COND 0x7
#define FE_COND 0x9
#define FGE_COND 0xb
#define FG_COND 0x6
#define FLE_COND 0xd
#define FL_COND 0x4
#define FNE_COND 0x1
#define as_add(ra,rb,rd) as_i_abd2(ra,rb,rd,0)
#define as_addcc(ra,rb,rd) as_i_abd2(ra,rb,rd,0x10)
#define as_addcci(ra,i,rd) as_i_aid2(ra,i,rd,0x10)
#define as_addi(ra,i,rd) as_i_aid2(ra,i,rd,0)
#define as_andcci(ra,i,rd) as_i_aid2(ra,i,rd,0x11)
#define as_faddd(fa,fb,fd) as_i_fff2(fa,fb,fd,0x34,FADDD_OP)
#define as_fcmpd(fa,fb) as_i_fb2(fa,fb,0x35,0x52)
#define as_fdtoi(fa,fd) as_i_ff2(fa,fd,0x34,0xd2)
#define as_fitod(fa,fd) as_i_ff2(fa,fd,0x34,0xc8)
#define as_fdivd(fa,fb,fd) as_i_fff2(fa,fb,fd,0x34,FDIVD_OP)
#define as_fmuld(fa,fb,fd) as_i_fff2(fa,fb,fd,0x34,FMULD_OP)
#define as_fsqrtd(fa,fd) as_i_ff2(fa,fd,0x34,0x2a)
#define as_fsubd(fa,fb,fd) as_i_fff2(fa,fb,fd,0x34,FSUBD_OP)
#define as_jmpli(i,ra,rd) as_i_aid2(ra,i,rd,0x38)
#define as_ld(o,ra,rd) as_i_aod3(ra,o,rd,LD_OP)
#define as_lddf(o,ra,fd) as_i_foa3(fd,o,ra,LDDF_OP)
#define as_ldf(o,ra,fd) as_i_foa3(fd,o,ra,LDF_OP)
#define as_ldf_x(ra,rb,fd) as_i_fab3(fd,ra,rb,LDF_OP)
#define as_ldsh(o,ra,rd) as_i_aod3(ra,o,rd,LDSH_OP)
#define as_ldsh_x(ra,rb,rd) as_i_abd3(ra,rb,rd,LDSH_OP)
#define as_ld_x(ra,rb,rd) as_i_abd3(ra,rb,rd,LD_OP)
#define as_fmovs(fa,fd) as_i_ff2(fa,fd,0x34,1);
#define as_fnegs(fa,fd) as_i_ff2(fa,fd,0x34,5);
#define as_or(ra,rb,rd) as_i_abd2(ra,rb,rd,OR_OP)
#define as_orcc(ra,rb,rd) as_i_abd2(ra,rb,rd,0x12)
#define as_ori(ra,i,rd) as_i_aid2(ra,i,rd,OR_OP)
#define as_sethi(i,rd) as_i_id0(i,rd)
#define as_slli(ra,i,rd) as_i_aid2(ra,i,rd,SLL_OP)
#define as_stf(fa,o,rd) as_i_foa3(fa,o,rd,STF_OP)
#define as_sub(ra,rb,rd) as_i_abd2(ra,rb,rd,4)
#define as_subcc(ra,rb,rd) as_i_abd2(ra,rb,rd,0x14)
#define as_subcci(ra,i,rd) as_i_aid2(ra,i,rd,0x14)
#define as_btst(i,ra) as_i_aid2(ra,i,REGISTER_G0,0x11)
#define as_clr(rd) as_or(REGISTER_G0,REGISTER_G0,rd)
#define as_cmp(ra,rb) as_subcc(ra,rb,REGISTER_G0)
#define as_cmpi(ra,i) as_subcci(ra,i,REGISTER_G0)
#define as_dec(i,rd) as_i_aid2(rd,i,rd,4)
#define as_deccc(i,rd) as_i_aid2(rd,i,rd,0x14)
#define as_inc(i,rd) as_i_aid2(rd,i,rd,0)
#define as_inccc(i,rd) as_i_aid2(rd,i,rd,0x10)
#define as_mov(ra,rd) as_or(REGISTER_G0,ra,rd)
#define as_movi(i,rd) as_ori(REGISTER_G0,i,rd)
#define as_nop() as_sethi(0,REGISTER_G0)
#define as_retl() as_jmpli(8,REGISTER_O7,REGISTER_G0)
#define as_tst(ra) as_orcc(REGISTER_G0,ra,REGISTER_G0)
#define as_load(op,o,ra,rd) as_i_aod3(ra,o,rd,op)
#define as_load_x(op,ra,rb,rd) as_i_abd3(ra,rb,rd,op)
#define as_store(op,rd,o,ra) as_i_aod3(ra,o,rd,op)
#define as_store_x(op,rd,ra,rb) as_i_abd3(ra,rb,rd,op)
#define as_st(rd,o,ra) as_store(ST_OP,rd,o,ra)
static void as_set (int i,int rd)
{
if (i>=-4096 && i<=4095)
as_movi (i,rd);
else {
as_sethi (i>>10,rd);
if ((i & 1023)!=0)
as_ori (rd,i & 1023,rd);
}
}
enum { SIZE_LONG, SIZE_WORD, SIZE_BYTE };
static void as_ld_parameter (struct parameter *parameter,int rd)
{
if (parameter->parameter_type==P_INDIRECT)
as_ld (parameter->parameter_offset,parameter->parameter_data.reg.r,rd);
else if (parameter->parameter_type==P_INDEXED && parameter->parameter_offset==0)
as_ld_x (parameter->parameter_data.ir->a_reg.r,parameter->parameter_data.ir->d_reg.r,rd);
else
internal_error_in_function ("as_ld_parameter");
}
static void as_ldsh_parameter (struct parameter *parameter,int rd)
{
if (parameter->parameter_type==P_INDIRECT)
as_ldsh (parameter->parameter_offset,parameter->parameter_data.reg.r,rd);
else if (parameter->parameter_type==P_INDEXED && parameter->parameter_offset==0)
as_ldsh_x (parameter->parameter_data.ir->a_reg.r,parameter->parameter_data.ir->d_reg.r,rd);
else
internal_error_in_function ("as_ldsh_parameter");
}
static struct parameter as_register_parameter (struct parameter parameter,int size_flag)
{
switch (parameter.parameter_type){
case P_DESCRIPTOR_NUMBER:
as_sethi (0,REGISTER_O0);
as_hi_or_lo_label (parameter.parameter_data.l,2+(parameter.parameter_offset<<3),HI22_RELOCATION);
as_ori (REGISTER_O0,0,REGISTER_O0);
as_hi_or_lo_label (parameter.parameter_data.l,2+(parameter.parameter_offset<<3),LO12_RELOCATION);
parameter.parameter_type=P_REGISTER;
parameter.parameter_data.reg.r=REGISTER_O0;
break;
case P_IMMEDIATE:
if (parameter.parameter_data.i==0){
parameter.parameter_type=P_REGISTER;
parameter.parameter_data.reg.r=REGISTER_G0;
} else {
as_set (parameter.parameter_data.i,REGISTER_O0);
parameter.parameter_type=P_REGISTER;
parameter.parameter_data.reg.r=REGISTER_O0;
}
break;
case P_REGISTER:
break;
case P_INDIRECT:
as_load (size_flag==SIZE_LONG ? LD_OP : size_flag==SIZE_WORD ? LDSH_OP : LDUB_OP,
parameter.parameter_offset,parameter.parameter_data.reg.r,REGISTER_O0);
parameter.parameter_type=P_REGISTER;
parameter.parameter_data.reg.r=REGISTER_O0;
break;
case P_INDEXED:
if (parameter.parameter_offset!=0)
internal_error_in_function ("as_register_parameter");
as_load_x (size_flag==SIZE_LONG ? LD_OP : size_flag==SIZE_WORD ? LDSH_OP : LDUB_OP,
parameter.parameter_data.ir->a_reg.r,parameter.parameter_data.ir->d_reg.r,REGISTER_O0);
parameter.parameter_type=P_REGISTER;
parameter.parameter_data.reg.r=REGISTER_O0;
break;
default:
internal_error_in_function ("as_register_parameter");
}
return parameter;
}
static void as_move_instruction (struct instruction *instruction,int size_flag)
{
switch (instruction->instruction_parameters[1].parameter_type){
case P_REGISTER:
switch (instruction->instruction_parameters[0].parameter_type){
case P_DESCRIPTOR_NUMBER:
as_sethi (0,instruction->instruction_parameters[1].parameter_data.reg.r);
as_hi_or_lo_label ( instruction->instruction_parameters[0].parameter_data.l,
2+(instruction->instruction_parameters[0].parameter_offset<<3),HI22_RELOCATION);
as_ori (instruction->instruction_parameters[1].parameter_data.reg.r,0,
instruction->instruction_parameters[1].parameter_data.reg.r);
as_hi_or_lo_label ( instruction->instruction_parameters[0].parameter_data.l,
2+(instruction->instruction_parameters[0].parameter_offset<<3),LO12_RELOCATION);
break;
case P_IMMEDIATE:
as_set (instruction->instruction_parameters[0].parameter_data.i,
instruction->instruction_parameters[1].parameter_data.reg.r);
break;
case P_REGISTER:
as_mov (instruction->instruction_parameters[0].parameter_data.reg.r,
instruction->instruction_parameters[1].parameter_data.reg.r);
return;
case P_INDIRECT:
as_load (size_flag==SIZE_LONG ? LD_OP : size_flag==SIZE_WORD ? LDSH_OP : LDUB_OP,
instruction->instruction_parameters[0].parameter_offset,
instruction->instruction_parameters[0].parameter_data.reg.r,
instruction->instruction_parameters[1].parameter_data.reg.r);
break;
case P_INDEXED:
if (instruction->instruction_parameters[0].parameter_offset!=0)
internal_error_in_function ("as_move_instruction");
as_load_x (size_flag==SIZE_LONG ? LD_OP : size_flag==SIZE_WORD ? LDSH_OP : LDUB_OP,
instruction->instruction_parameters[0].parameter_data.ir->a_reg.r,
instruction->instruction_parameters[0].parameter_data.ir->d_reg.r,
instruction->instruction_parameters[1].parameter_data.reg.r);
break;
default:
internal_error_in_function ("as_move_instruction");
return;
}
return;
case P_INDIRECT:
{
struct parameter parameter_0;
int offset;
parameter_0=as_register_parameter (instruction->instruction_parameters[0],size_flag);
offset=instruction->instruction_parameters[1].parameter_offset;
if (((offset << (32-13)) >> (32-13))==offset){
as_store (size_flag==SIZE_LONG ? ST_OP : size_flag==SIZE_WORD ? STH_OP : STB_OP,
parameter_0.parameter_data.reg.r,offset,instruction->instruction_parameters[1].parameter_data.reg.r);
} else {
as_sethi (offset>>10,REGISTER_O1);
as_add (REGISTER_O1,instruction->instruction_parameters[1].parameter_data.reg.r,REGISTER_O1);
as_store (size_flag==SIZE_LONG ? ST_OP : size_flag==SIZE_WORD ? STH_OP : STB_OP,
parameter_0.parameter_data.reg.r,offset & 1023,REGISTER_O1);
}
return;
}
case P_INDEXED:
{
struct parameter parameter_0;
if (instruction->instruction_parameters[1].parameter_offset!=0)
internal_error_in_function ("as_move_instruction");
parameter_0=as_register_parameter (instruction->instruction_parameters[0],size_flag);
as_store_x (size_flag==SIZE_LONG ? ST_OP : size_flag==SIZE_WORD ? STH_OP : STB_OP,
parameter_0.parameter_data.reg.r,instruction->instruction_parameters[1].parameter_data.ir->a_reg.r,
instruction->instruction_parameters[1].parameter_data.ir->d_reg.r);
return;
}
default:
internal_error_in_function ("as_move_instruction");
}
}
static void as_lea_instruction (struct instruction *instruction)
{
if (instruction->instruction_parameters[1].parameter_type==P_REGISTER)
switch (instruction->instruction_parameters[0].parameter_type){
case P_LABEL:
as_sethi (0,instruction->instruction_parameters[1].parameter_data.reg.r);
as_hi_or_lo_label ( instruction->instruction_parameters[0].parameter_data.l,
instruction->instruction_parameters[0].parameter_offset,HI22_RELOCATION);
as_ori (instruction->instruction_parameters[1].parameter_data.reg.r,0,
instruction->instruction_parameters[1].parameter_data.reg.r);
as_hi_or_lo_label ( instruction->instruction_parameters[0].parameter_data.l,
instruction->instruction_parameters[0].parameter_offset,LO12_RELOCATION);
return;
case P_INDIRECT:
as_addi (instruction->instruction_parameters[0].parameter_data.reg.r,
instruction->instruction_parameters[0].parameter_offset,
instruction->instruction_parameters[1].parameter_data.reg.r);
return;
case P_INDEXED:
as_add (instruction->instruction_parameters[0].parameter_data.ir->a_reg.r,
instruction->instruction_parameters[0].parameter_data.ir->d_reg.r,
instruction->instruction_parameters[1].parameter_data.reg.r);
return;
}
internal_error_in_function ("as_lea_instruction");
}
static void as_sll_instruction (struct instruction *instruction)
{
as_slli ( instruction->instruction_parameters[0].parameter_data.reg.r,
instruction->instruction_parameters[2].parameter_data.i,
instruction->instruction_parameters[1].parameter_data.reg.r);
}
static void as_logical_or_shift_instruction (struct instruction *instruction,int opcode)
{
struct parameter parameter;
parameter=instruction->instruction_parameters[0];
switch (parameter.parameter_type){
case P_IMMEDIATE:
if ((unsigned)(parameter.parameter_data.i+4096)>=(unsigned)8192){
as_set (parameter.parameter_data.i,REGISTER_O0);
parameter.parameter_type=P_REGISTER;
parameter.parameter_data.reg.r=REGISTER_O0;
} else {
as_i_aid2 ( instruction->instruction_parameters[1].parameter_data.reg.r,
parameter.parameter_data.i,
instruction->instruction_parameters[1].parameter_data.reg.r,opcode);
return;
}
break;
case P_INDIRECT:
as_ld (parameter.parameter_offset,parameter.parameter_data.reg.r,REGISTER_O0);
parameter.parameter_type=P_REGISTER;
parameter.parameter_data.reg.r=REGISTER_O0;
break;
case P_INDEXED:
if (parameter.parameter_offset!=0)
internal_error_in_function ("as_tryadic_instruction");
as_ld_x (parameter.parameter_data.ir->a_reg.r,parameter.parameter_data.ir->d_reg.r,REGISTER_O0);
parameter.parameter_type=P_REGISTER;
parameter.parameter_data.reg.r=REGISTER_O0;
}
as_i_abd2 ( instruction->instruction_parameters[1].parameter_data.reg.r,
parameter.parameter_data.reg.r,
instruction->instruction_parameters[1].parameter_data.reg.r,opcode);
}
static void as_add_instruction (struct instruction *instruction)
{
switch (instruction->instruction_parameters[0].parameter_type){
case P_REGISTER:
as_add (instruction->instruction_parameters[1].parameter_data.reg.r,
instruction->instruction_parameters[0].parameter_data.reg.r,
instruction->instruction_parameters[1].parameter_data.reg.r);
return;
case P_IMMEDIATE:
if ((unsigned)(instruction->instruction_parameters[0].parameter_data.i+4096)<(unsigned)8192){
as_inc (instruction->instruction_parameters[0].parameter_data.i,
instruction->instruction_parameters[1].parameter_data.reg.r);
return;
} else {
as_set (instruction->instruction_parameters[0].parameter_data.i,REGISTER_O0);
as_add (instruction->instruction_parameters[1].parameter_data.reg.r,REGISTER_O0,
instruction->instruction_parameters[1].parameter_data.reg.r);
return;
}
default:
as_ld_parameter (&instruction->instruction_parameters[0],REGISTER_O0);
as_add (instruction->instruction_parameters[1].parameter_data.reg.r,REGISTER_O0,
instruction->instruction_parameters[1].parameter_data.reg.r);
}
}
static void as_add_o_instruction (struct instruction *instruction)
{
switch (instruction->instruction_parameters[0].parameter_type){
case P_REGISTER:
as_addcc ( instruction->instruction_parameters[1].parameter_data.reg.r,
instruction->instruction_parameters[0].parameter_data.reg.r,
instruction->instruction_parameters[1].parameter_data.reg.r);
return;
case P_IMMEDIATE:
if ((unsigned)(instruction->instruction_parameters[0].parameter_data.i+4096)<(unsigned)8192){
as_inccc ( instruction->instruction_parameters[0].parameter_data.i,
instruction->instruction_parameters[1].parameter_data.reg.r);
return;
} else {
as_set (instruction->instruction_parameters[0].parameter_data.i,REGISTER_O0);
as_addcc (instruction->instruction_parameters[1].parameter_data.reg.r,REGISTER_O0,
instruction->instruction_parameters[1].parameter_data.reg.r);
return;
}
default:
as_ld_parameter (&instruction->instruction_parameters[0],REGISTER_O0);
as_addcc ( instruction->instruction_parameters[1].parameter_data.reg.r,REGISTER_O0,
instruction->instruction_parameters[1].parameter_data.reg.r);
}
}
static void as_sub_instruction (struct instruction *instruction)
{
switch (instruction->instruction_parameters[0].parameter_type){
case P_REGISTER:
as_sub (instruction->instruction_parameters[1].parameter_data.reg.r,
instruction->instruction_parameters[0].parameter_data.reg.r,
instruction->instruction_parameters[1].parameter_data.reg.r);
return;
case P_IMMEDIATE:
if ((unsigned)(instruction->instruction_parameters[0].parameter_data.i+4096)<(unsigned)8192){
as_dec (instruction->instruction_parameters[0].parameter_data.i,
instruction->instruction_parameters[1].parameter_data.reg.r);
return;
} else {
as_set (instruction->instruction_parameters[0].parameter_data.i,REGISTER_O0);
as_sub (instruction->instruction_parameters[1].parameter_data.reg.r,REGISTER_O0,
instruction->instruction_parameters[1].parameter_data.reg.r);
return;
}
default:
as_ld_parameter (&instruction->instruction_parameters[0],REGISTER_O0);
as_sub (instruction->instruction_parameters[1].parameter_data.reg.r,REGISTER_O0,
instruction->instruction_parameters[1].parameter_data.reg.r);
}
}
static void as_sub_o_instruction (struct instruction *instruction)
{
switch (instruction->instruction_parameters[0].parameter_type){
case P_REGISTER:
as_subcc (instruction->instruction_parameters[1].parameter_data.reg.r,
instruction->instruction_parameters[0].parameter_data.reg.r,
instruction->instruction_parameters[1].parameter_data.reg.r);
return;
case P_IMMEDIATE:
if ((unsigned)(instruction->instruction_parameters[0].parameter_data.i+4096)<(unsigned)8192){
as_deccc (instruction->instruction_parameters[0].parameter_data.i,
instruction->instruction_parameters[1].parameter_data.reg.r);
return;
} else {
as_set (instruction->instruction_parameters[0].parameter_data.i,REGISTER_O0);
as_subcc (instruction->instruction_parameters[1].parameter_data.reg.r,REGISTER_O0,
instruction->instruction_parameters[1].parameter_data.reg.r);
return;
}
default:
as_ld_parameter (&instruction->instruction_parameters[0],REGISTER_O0);
as_subcc (instruction->instruction_parameters[1].parameter_data.reg.r,REGISTER_O0,
instruction->instruction_parameters[1].parameter_data.reg.r);
}
}
static void as_cmp_instruction (struct instruction *instruction,int size_flag)
{
struct parameter parameter_0,parameter_1;
parameter_0=instruction->instruction_parameters[0];
parameter_1=instruction->instruction_parameters[1];
if (parameter_1.parameter_type==P_INDIRECT){
if (size_flag==SIZE_LONG)
as_ld (parameter_1.parameter_offset,parameter_1.parameter_data.reg.r,REGISTER_O1);
else
as_ldsh (parameter_1.parameter_offset,parameter_1.parameter_data.reg.r,REGISTER_O1);
parameter_1.parameter_type=P_REGISTER;
parameter_1.parameter_data.reg.r=REGISTER_O1;
} else if (parameter_1.parameter_type==P_INDEXED){
if (parameter_1.parameter_offset!=0)
internal_error_in_function ("as_cmp_instruction");
if (size_flag==SIZE_LONG)
as_ld_x (parameter_1.parameter_data.ir->a_reg.r,parameter_1.parameter_data.ir->d_reg.r,REGISTER_O1);
else
as_ldsh_x (parameter_1.parameter_data.ir->a_reg.r,parameter_1.parameter_data.ir->d_reg.r,REGISTER_O1);
parameter_1.parameter_type=P_REGISTER;
parameter_1.parameter_data.reg.r=REGISTER_O1;
}
switch (parameter_0.parameter_type){
case P_DESCRIPTOR_NUMBER:
as_sethi (0,REGISTER_O0);
as_hi_or_lo_label (parameter_0.parameter_data.l,2+(parameter_0.parameter_offset<<3),HI22_RELOCATION);
as_ori (REGISTER_O0,0,REGISTER_O0);
as_hi_or_lo_label (parameter_0.parameter_data.l,2+(parameter_0.parameter_offset<<3),LO12_RELOCATION);
parameter_0.parameter_type=P_REGISTER;
parameter_0.parameter_data.reg.r=REGISTER_O0;
break;
case P_IMMEDIATE:
if ((unsigned)(parameter_0.parameter_data.i+4096)>=(unsigned)8192){
as_set (parameter_0.parameter_data.i,REGISTER_O0);
parameter_0.parameter_type=P_REGISTER;
parameter_0.parameter_data.reg.r=REGISTER_O0;
} else {
as_cmpi (parameter_1.parameter_data.reg.r,parameter_0.parameter_data.i);
return;
}
break;
case P_REGISTER:
break;
default:
switch (size_flag){
case SIZE_WORD:
as_ldsh_parameter (¶meter_0,REGISTER_O0);
break;
case SIZE_LONG:
as_ld_parameter (¶meter_0,REGISTER_O0);
break;
default:
internal_error_in_function ("as_cmp_instruction");
}
parameter_0.parameter_type=P_REGISTER;
parameter_0.parameter_data.reg.r=REGISTER_O0;
}
as_cmp (parameter_1.parameter_data.reg.r,parameter_0.parameter_data.reg.r);
}
static void as_tst_instruction (struct instruction *instruction,int size_flag)
{
struct parameter parameter_0;
if (size_flag!=SIZE_LONG)
internal_error_in_function ("as_tst_instruction");
parameter_0=as_register_parameter (instruction->instruction_parameters[0],size_flag);
as_tst (parameter_0.parameter_data.reg.r);
}
static void as_btst_instruction (struct instruction *instruction)
{
as_btst (instruction->instruction_parameters[0].parameter_data.i,
instruction->instruction_parameters[1].parameter_data.reg.r);
}
void as_jmp_instruction (struct instruction *instruction)
{
if (instruction->instruction_parameters[0].parameter_type==P_LABEL){
if (instruction->instruction_parameters[0].parameter_data.l->label_flags & LOCAL_LABEL){
as_i_bica (0,A_COND);
as_branch_label (instruction->instruction_parameters[0].parameter_data.l,BRANCH_RELOCATION);
return;
} else {
as_i_call (0);
as_branch_label (instruction->instruction_parameters[0].parameter_data.l,CALL_RELOCATION);
as_nop();
}
} else if (instruction->instruction_parameters[0].parameter_type==P_INDIRECT){
as_jmpli ( instruction->instruction_parameters[0].parameter_offset,
instruction->instruction_parameters[0].parameter_data.reg.r,REGISTER_G0);
as_nop();
} else
internal_error_in_function ("as_jmp_instruction");
}
static void as_branch_instruction (struct instruction *instruction,int condition)
{
as_i_bic (0,condition);
as_branch_label (instruction->instruction_parameters[0].parameter_data.l,BRANCH_RELOCATION);
as_nop();
}
static void as_index_error_branch_instruction (struct instruction *instruction)
{
as_i_bic (12>>2,CS_COND);
as_nop();
as_i_bica (0,A_COND);
as_branch_label (instruction->instruction_parameters[0].parameter_data.l,BRANCH_RELOCATION);
}
static void as_float_branch_instruction (struct instruction *instruction,int condition)
{
as_nop();
as_i_fbic (0,condition);
as_branch_label (instruction->instruction_parameters[0].parameter_data.l,BRANCH_RELOCATION);
as_nop();
}
static void as_jsr_instruction (struct instruction *instruction)
{
if (instruction->instruction_parameters[0].parameter_type==P_LABEL){
as_i_call (0);
as_branch_label (instruction->instruction_parameters[0].parameter_data.l,CALL_RELOCATION);
if (instruction->instruction_parameters[1].parameter_type==P_INDIRECT)
as_st (REGISTER_O7,instruction->instruction_parameters[1].parameter_data.i,B_STACK_POINTER);
else
as_nop();
} else if (instruction->instruction_parameters[1].parameter_type==P_INDIRECT){
as_jmpli ( instruction->instruction_parameters[0].parameter_offset,
instruction->instruction_parameters[0].parameter_data.reg.r,REGISTER_O7);
as_st (REGISTER_O7,instruction->instruction_parameters[1].parameter_data.i,B_STACK_POINTER);
} else
internal_error_in_function ("as_jsr_instruction");
}
static void as_rts_instruction (struct instruction *instruction)
{
int b_offset;
as_ld (instruction->instruction_parameters[0].parameter_offset,B_STACK_POINTER,REGISTER_O7);
as_retl();
b_offset=instruction->instruction_parameters[1].parameter_data.i;
if (b_offset==0)
as_nop();
else {
if (b_offset<0)
as_dec (-b_offset,B_STACK_POINTER);
else
as_inc (b_offset,B_STACK_POINTER);
}
}
static void as_set_condition_instruction (struct instruction *instruction,int condition)
{
as_clr (instruction->instruction_parameters[0].parameter_data.reg.r);
as_i_bica (2-1,condition);
as_movi (-1,instruction->instruction_parameters[0].parameter_data.reg.r);
}
static void as_set_float_condition_instruction (struct instruction *instruction,int condition)
{
as_nop();
as_clr (instruction->instruction_parameters[0].parameter_data.reg.r);
as_i_fbica (2-1,condition);
as_movi (-1,instruction->instruction_parameters[0].parameter_data.reg.r);
}
extern struct label *dot_rem_label,*dot_div_label,*dot_mul_label;
static void w_as_mod_instruction (struct instruction *instruction)
{
as_mov (instruction->instruction_parameters[2].parameter_data.reg.r,REGISTER_O0);
switch (instruction->instruction_parameters[0].parameter_type){
case P_REGISTER:
as_i_call (0);
as_branch_label (dot_rem_label,CALL_RELOCATION);
as_mov (instruction->instruction_parameters[0].parameter_data.reg.r,REGISTER_O1);
break;
case P_IMMEDIATE:
{
long v;
v=instruction->instruction_parameters[0].parameter_data.i;
if ((unsigned)(v+4096) < (unsigned)8192){
as_i_call (0);
as_branch_label (dot_rem_label,CALL_RELOCATION);
as_movi (v,REGISTER_O1);
} else {
as_sethi (v>>10,REGISTER_O1);
as_i_call (0);
as_branch_label (dot_rem_label,CALL_RELOCATION);
as_ori (REGISTER_O1,v & 1023,REGISTER_O1);
}
break;
}
default:
as_i_call (0);
as_branch_label (dot_rem_label,CALL_RELOCATION);
as_ld_parameter (&instruction->instruction_parameters[0],REGISTER_O1);
}
as_mov (REGISTER_O0,instruction->instruction_parameters[1].parameter_data.reg.r);
}
static void w_as_mul_or_div_instruction (struct instruction *instruction,struct label *mul_or_div_label)
{
as_mov (instruction->instruction_parameters[1].parameter_data.reg.r,REGISTER_O0);
switch (instruction->instruction_parameters[0].parameter_type){
case P_REGISTER:
as_i_call (0);
as_branch_label (mul_or_div_label,CALL_RELOCATION);
as_mov (instruction->instruction_parameters[0].parameter_data.reg.r,REGISTER_O1);
break;
case P_IMMEDIATE:
{
long v;
v=instruction->instruction_parameters[0].parameter_data.i;
if ((unsigned)(v+4096) < (unsigned)8192){
as_i_call (0);
as_branch_label (mul_or_div_label,CALL_RELOCATION);
as_movi (v,REGISTER_O1);
} else {
as_sethi (v>>10,REGISTER_O1);
as_i_call (0);
as_branch_label (mul_or_div_label,CALL_RELOCATION);
as_ori (REGISTER_O1,v & 1023,REGISTER_O1);
}
break;
}
default:
as_i_call (0);
as_branch_label (mul_or_div_label,CALL_RELOCATION);
as_ld_parameter (&instruction->instruction_parameters[0],REGISTER_O1);
}
as_mov (REGISTER_O0,instruction->instruction_parameters[1].parameter_data.reg.r);
}
#ifndef FUNCTION_LEVEL_LINKING
static int data_section_alignment_mask;
#endif
static void as_load_float_immediate (double float_value,int fp_reg)
{
struct label *new_label;
new_label=allocate_memory_from_heap_type (struct label);
new_label->label_flags=DATA_LABEL;
new_label->label_id=DATA_LABEL_ID;
#ifdef FUNCTION_LEVEL_LINKING
new_label->label_object_label=data_object_label;
data_object_label->object_section_align8=1;
#else
data_section_alignment_mask |= 7;
#endif
#ifdef FUNCTION_LEVEL_LINKING
if ((((unsigned char*)data_buffer_p-current_data_buffer->data)-data_object_label->object_label_offset) & 4)
#else
if ((((unsigned char*)data_buffer_p-current_data_buffer->data) & 4)!=0)
#endif
store_long_word_in_data_section (0);
new_label->label_offset=CURRENT_DATA_OFFSET;
new_label->label_number=next_label_id++;
store_long_word_in_data_section (((ULONG*)&float_value)[0]);
store_long_word_in_data_section (((ULONG*)&float_value)[1]);
as_sethi (0,REGISTER_O0);
as_hi_or_lo_label (new_label,0,HI22_RELOCATION);
as_lddf (0,REGISTER_O0,fp_reg<<1);
as_hi_or_lo_label (new_label,0,LO12_RELOCATION);
}
static struct parameter as_float_parameter (struct parameter parameter)
{
switch (parameter.parameter_type){
case P_F_IMMEDIATE:
as_load_float_immediate (*parameter.parameter_data.r,15);
parameter.parameter_type=P_F_REGISTER;
parameter.parameter_data.reg.r=15;
break;
case P_INDIRECT:
as_ldf (parameter.parameter_offset,parameter.parameter_data.reg.r,30);
as_ldf (parameter.parameter_offset+4,parameter.parameter_data.reg.r,31);
parameter.parameter_type=P_F_REGISTER;
parameter.parameter_data.reg.r=15;
break;
case P_INDEXED:
as_add (parameter.parameter_data.ir->a_reg.r,parameter.parameter_data.ir->d_reg.r,REGISTER_O0);
as_ldf (parameter.parameter_offset>>2,REGISTER_O0,30);
as_ldf ((parameter.parameter_offset>>2)+4,REGISTER_O0,31);
parameter.parameter_type=P_F_REGISTER;
parameter.parameter_data.reg.r=15;
break;
}
return parameter;
}
static void as_compare_float_instruction (struct instruction *instruction)
{
struct parameter parameter_0;
parameter_0=as_float_parameter (instruction->instruction_parameters[0]);
as_fcmpd (instruction->instruction_parameters[1].parameter_data.reg.r<<1,parameter_0.parameter_data.reg.r<<1);
}
static void as_sqrt_float_instruction (struct instruction *instruction)
{
struct parameter parameter_0;
parameter_0=as_float_parameter (instruction->instruction_parameters[0]);
as_fsqrtd (parameter_0.parameter_data.reg.r<<1,instruction->instruction_parameters[1].parameter_data.reg.r<<1);
}
static void as_neg_float_instruction (struct instruction *instruction)
{
struct parameter parameter_0;
int freg1,freg2;
parameter_0=as_float_parameter (instruction->instruction_parameters[0]);
freg1=parameter_0.parameter_data.reg.r;
freg2=instruction->instruction_parameters[1].parameter_data.reg.r;
as_fnegs (freg1<<1,freg2<<1);
if (freg1!=freg2)
as_fmovs ((freg1<<1)+1,(freg2<<1)+1);
}
static void as_tryadic_float_instruction (struct instruction *instruction,int opcode)
{
struct parameter parameter_0;
parameter_0=as_float_parameter (instruction->instruction_parameters[0]);
as_i_fff2 (instruction->instruction_parameters[1].parameter_data.reg.r<<1,
parameter_0.parameter_data.reg.r<<1,
instruction->instruction_parameters[1].parameter_data.reg.r<<1,
0x34,opcode);
}
static struct instruction *as_fmove_instruction (struct instruction *instruction)
{
switch (instruction->instruction_parameters[1].parameter_type){
case P_F_REGISTER:
switch (instruction->instruction_parameters[0].parameter_type){
case P_F_REGISTER:
{
struct instruction *next_instruction;
int reg0,reg1;
reg0=instruction->instruction_parameters[0].parameter_data.reg.r;
reg1=instruction->instruction_parameters[1].parameter_data.reg.r;
next_instruction=instruction->instruction_next;
if (next_instruction)
switch (next_instruction->instruction_icode){
case IFADD: case IFSUB: case IFMUL: case IFDIV:
if (next_instruction->instruction_parameters[1].parameter_data.reg.r==reg1)
{
struct parameter parameter_0;
int reg_s;
parameter_0=as_float_parameter (next_instruction->instruction_parameters[0]);
reg_s=parameter_0.parameter_data.reg.r;
if (reg_s==reg1)
reg_s=reg0;
switch (next_instruction->instruction_icode){
case IFADD:
as_faddd (reg0<<1,reg_s<<1,reg1<<1);
break;
case IFSUB:
as_fsubd (reg0<<1,reg_s<<1,reg1<<1);
break;
case IFMUL:
as_fmuld (reg0<<1,reg_s<<1,reg1<<1);
break;
case IFDIV:
as_fdivd (reg0<<1,reg_s<<1,reg1<<1);
break;
}
return next_instruction;
}
}
as_fmovs (reg0<<1,reg1<<1);
as_fmovs ((reg0<<1)+1,(reg1<<1)+1);
return instruction;
}
case P_INDIRECT:
as_ldf (instruction->instruction_parameters[0].parameter_offset,
instruction->instruction_parameters[0].parameter_data.reg.r,
instruction->instruction_parameters[1].parameter_data.reg.r<<1);
as_ldf (instruction->instruction_parameters[0].parameter_offset+4,
instruction->instruction_parameters[0].parameter_data.reg.r,
(instruction->instruction_parameters[1].parameter_data.reg.r<<1)+1);
return instruction;
case P_INDEXED:
as_add (instruction->instruction_parameters[0].parameter_data.ir->a_reg.r,
instruction->instruction_parameters[0].parameter_data.ir->d_reg.r,REGISTER_O0);
as_ldf (instruction->instruction_parameters[0].parameter_offset>>2,REGISTER_O0,
instruction->instruction_parameters[1].parameter_data.reg.r<<1);
as_ldf ((instruction->instruction_parameters[0].parameter_offset>>2)+4,REGISTER_O0,
(instruction->instruction_parameters[1].parameter_data.reg.r<<1)+1);
return instruction;
case P_F_IMMEDIATE:
as_load_float_immediate (*instruction->instruction_parameters[0].parameter_data.r,instruction->instruction_parameters[1].parameter_data.reg.r);
return instruction;
}
break;
case P_INDIRECT:
if (instruction->instruction_parameters[0].parameter_type==P_F_REGISTER){
as_stf (instruction->instruction_parameters[0].parameter_data.reg.r<<1,
instruction->instruction_parameters[1].parameter_offset,
instruction->instruction_parameters[1].parameter_data.reg.r);
as_stf ((instruction->instruction_parameters[0].parameter_data.reg.r<<1)+1,
instruction->instruction_parameters[1].parameter_offset+4,
instruction->instruction_parameters[1].parameter_data.reg.r);
return instruction;
}
break;
case P_INDEXED:
if (instruction->instruction_parameters[0].parameter_type==P_F_REGISTER){
as_add (instruction->instruction_parameters[1].parameter_data.ir->a_reg.r,
instruction->instruction_parameters[1].parameter_data.ir->d_reg.r,REGISTER_O0);
as_stf (instruction->instruction_parameters[0].parameter_data.reg.r<<1,
instruction->instruction_parameters[1].parameter_offset>>2,REGISTER_O0);
as_stf ((instruction->instruction_parameters[0].parameter_data.reg.r<<1)+1,
(instruction->instruction_parameters[1].parameter_offset>>2)+4,REGISTER_O0);
return instruction;
}
}
internal_error_in_function ("as_fmove_instruction");
return instruction;
}
static void as_fmove_hl_instruction (struct instruction *instruction)
{
if (instruction->instruction_parameters[0].parameter_type==P_INDIRECT
&& instruction->instruction_parameters[1].parameter_type==P_F_REGISTER)
{
if (instruction->instruction_icode==IFMOVEHI)
as_ldf (instruction->instruction_parameters[0].parameter_offset,
instruction->instruction_parameters[0].parameter_data.reg.r,
instruction->instruction_parameters[1].parameter_data.reg.r<<1);
else
as_ldf (instruction->instruction_parameters[0].parameter_offset,
instruction->instruction_parameters[0].parameter_data.reg.r,
(instruction->instruction_parameters[1].parameter_data.reg.r<<1)+1);
return;
}
internal_error_in_function ("as_fmove_hl_instruction");
}
static void as_fmovel_instruction (struct instruction *instruction)
{
if (instruction->instruction_parameters[0].parameter_type==P_F_REGISTER){
if (instruction->instruction_parameters[1].parameter_type!=P_REGISTER)
internal_error_in_function ("as_fmovel_instruction");
as_fdtoi (instruction->instruction_parameters[0].parameter_data.reg.r<<1,31);
as_stf (31,-4,REGISTER_I6);
as_ld (-4,REGISTER_I6,instruction->instruction_parameters[1].parameter_data.reg.r);
} else {
switch (instruction->instruction_parameters[0].parameter_type){
case P_REGISTER:
as_st (instruction->instruction_parameters[0].parameter_data.reg.r,-4,REGISTER_I6);
as_ldf (-4,REGISTER_I6,31);
break;
case P_INDIRECT:
as_ldf (instruction->instruction_parameters[0].parameter_offset,
instruction->instruction_parameters[0].parameter_data.reg.r,31);
break;
case P_INDEXED:
if (instruction->instruction_parameters[0].parameter_offset!=0)
internal_error_in_function ("as_movel_instruction");
as_ldf_x (instruction->instruction_parameters[0].parameter_data.ir->a_reg.r,
instruction->instruction_parameters[0].parameter_data.ir->d_reg.r,31);
break;
case P_IMMEDIATE:
as_set (instruction->instruction_parameters[0].parameter_data.i,REGISTER_O0);
as_st (REGISTER_O0,-4,REGISTER_I6);
as_ldf (-4,REGISTER_I6,31);
break;
default:
internal_error_in_function ("as_fmovel_instruction");
}
as_fitod (31,instruction->instruction_parameters[1].parameter_data.reg.r<<1);
}
}
static void as_instructions (register struct instruction *instruction)
{
while (instruction!=NULL){
switch (instruction->instruction_icode){
case IMOVE:
as_move_instruction (instruction,SIZE_LONG);
break;
case ILEA:
as_lea_instruction (instruction);
break;
case IADD:
as_add_instruction (instruction);
break;
case IADDI:
as_addi (instruction->instruction_parameters[0].parameter_data.reg.r,
instruction->instruction_parameters[2].parameter_data.i,
instruction->instruction_parameters[1].parameter_data.reg.r);
break;
case ISUB:
as_sub_instruction (instruction);
break;
case ICMP:
as_cmp_instruction (instruction,SIZE_LONG);
break;
case IJMP:
as_jmp_instruction (instruction);
break;
case IJSR:
as_jsr_instruction (instruction);
break;
case IRTS:
as_rts_instruction (instruction);
break;
case IBEQ:
as_branch_instruction (instruction,E_COND);
break;
case IBGE:
as_branch_instruction (instruction,GE_COND);
break;
case IBGT:
as_branch_instruction (instruction,G_COND);
break;
case IBHS:
as_index_error_branch_instruction (instruction);
break;
case IBLE:
as_branch_instruction (instruction,LE_COND);
break;
case IBLT:
as_branch_instruction (instruction,L_COND);
break;
case IBNE:
as_branch_instruction (instruction,NE_COND);
break;
case IBNO:
as_branch_instruction (instruction,VC_COND);
break;
case IBO:
as_branch_instruction (instruction,VS_COND);
break;
case ILSLI:
as_sll_instruction (instruction);
break;
case ILSL:
as_logical_or_shift_instruction (instruction,SLL_OP);
break;
case ILSR:
as_logical_or_shift_instruction (instruction,SRL_OP);
break;
case IASR:
as_logical_or_shift_instruction (instruction,SRA_OP);
break;
case IMUL:
w_as_mul_or_div_instruction (instruction,dot_mul_label);
break;
case IDIV:
w_as_mul_or_div_instruction (instruction,dot_div_label);
break;
case IMOD:
w_as_mod_instruction (instruction);
break;
case IAND:
as_logical_or_shift_instruction (instruction,AND_OP);
break;
case IOR:
as_logical_or_shift_instruction (instruction,OR_OP);
break;
case IEOR:
as_logical_or_shift_instruction (instruction,XOR_OP);
break;
case ISEQ:
as_set_condition_instruction (instruction,E_COND);
break;
case ISGE:
as_set_condition_instruction (instruction,GE_COND);
break;
case ISGT:
as_set_condition_instruction (instruction,G_COND);
break;
case ISLE:
as_set_condition_instruction (instruction,LE_COND);
break;
case ISLT:
as_set_condition_instruction (instruction,L_COND);
break;
case ISNE:
as_set_condition_instruction (instruction,NE_COND);
break;
case ISNO:
as_set_condition_instruction (instruction,VC_COND);
break;
case ISO:
as_set_condition_instruction (instruction,VS_COND);
break;
case ICMPW:
as_cmp_instruction (instruction,SIZE_WORD);
break;
case ITST:
as_tst_instruction (instruction,SIZE_LONG);
break;
case IBTST:
as_btst_instruction (instruction);
break;
case IMOVEW:
as_move_instruction (instruction,SIZE_WORD);
break;
case IMOVEB:
as_move_instruction (instruction,SIZE_BYTE);
break;
case IFMOVE:
instruction=as_fmove_instruction (instruction);
break;
case IFMOVEHI:
case IFMOVELO:
as_fmove_hl_instruction (instruction);
break;
case IFADD:
as_tryadic_float_instruction (instruction,FADDD_OP);
break;
case IFSUB:
as_tryadic_float_instruction (instruction,FSUBD_OP);
break;
case IFCMP:
as_compare_float_instruction (instruction);
break;
case IFDIV:
as_tryadic_float_instruction (instruction,FDIVD_OP);
break;
case IFMUL:
as_tryadic_float_instruction (instruction,FMULD_OP);
break;
case IFBEQ:
as_float_branch_instruction (instruction,FE_COND);
break;
case IFBGE:
as_float_branch_instruction (instruction,FGE_COND);
break;
case IFBGT:
as_float_branch_instruction (instruction,FG_COND);
break;
case IFBLE:
as_float_branch_instruction (instruction,FLE_COND);
break;
case IFBLT:
as_float_branch_instruction (instruction,FL_COND);
break;
case IFBNE:
as_float_branch_instruction (instruction,FNE_COND);
break;
case IFMOVEL:
as_fmovel_instruction (instruction);
break;
case IFSQRT:
as_sqrt_float_instruction (instruction);
break;
case IFNEG:
as_neg_float_instruction (instruction);
break;
case IFSEQ:
as_set_float_condition_instruction (instruction,FE_COND);
break;
case IFSGE:
as_set_float_condition_instruction (instruction,FGE_COND);
break;
case IFSGT:
as_set_float_condition_instruction (instruction,FG_COND);
break;
case IFSLE:
as_set_float_condition_instruction (instruction,FLE_COND);
break;
case IFSLT:
as_set_float_condition_instruction (instruction,FL_COND);
break;
case IFSNE:
as_set_float_condition_instruction (instruction,FNE_COND);
break;
case IWORD:
store_instruction (instruction->instruction_parameters[0].parameter_data.i);
break;
case IADDO:
as_add_o_instruction (instruction);
break;
case ISUBO:
as_sub_o_instruction (instruction);
break;
case IFTST:
default:
internal_error_in_function ("as_instructions");
}
instruction=instruction->instruction_next;
}
}
static void as_number_of_arguments (int n_node_arguments)
{
store_instruction (n_node_arguments);
}
struct call_and_jump {
struct call_and_jump * cj_next;
struct label * cj_call_label;
struct label cj_label;
struct label cj_jump_label;
};
static struct call_and_jump *first_call_and_jump,*last_call_and_jump;
static void as_garbage_collect_test (struct basic_block *block)
{
LONG n_cells;
struct call_and_jump *new_call_and_jump;
new_call_and_jump=allocate_memory_from_heap (sizeof (struct call_and_jump));
new_call_and_jump->cj_next=NULL;
new_call_and_jump->cj_label.label_flags=0;
switch (block->block_n_begin_a_parameter_registers){
case 0: new_call_and_jump->cj_call_label=collect_0_label; break;
case 1: new_call_and_jump->cj_call_label=collect_1_label; break;
case 2: new_call_and_jump->cj_call_label=collect_2_label; break;
case 3: new_call_and_jump->cj_call_label=collect_3_label; break;
default: internal_error_in_function ("as_garbage_collect_test");
}
if (first_call_and_jump!=NULL)
last_call_and_jump->cj_next=new_call_and_jump;
else
first_call_and_jump=new_call_and_jump;
last_call_and_jump=new_call_and_jump;
n_cells=block->block_n_new_heap_cells;
if (n_cells<4096)
as_deccc (n_cells,REGISTER_D7);
else {
as_set (n_cells,REGISTER_O0);
as_subcc (REGISTER_D7,REGISTER_O0,REGISTER_D7);
}
as_i_bica (0,CS_COND);
as_branch_label (&new_call_and_jump->cj_label,BRANCH_RELOCATION);
as_dec (4,B_STACK_POINTER);
new_call_and_jump->cj_jump_label.label_flags=0;
new_call_and_jump->cj_jump_label.label_id=TEXT_LABEL_ID;
#ifdef FUNCTION_LEVEL_LINKING
new_call_and_jump->cj_jump_label.label_object_label=code_object_label;
#endif
new_call_and_jump->cj_jump_label.label_offset=CURRENT_CODE_OFFSET;
}
static void as_call_and_jump (struct call_and_jump *call_and_jump)
{
call_and_jump->cj_label.label_id=TEXT_LABEL_ID;
#ifdef FUNCTION_LEVEL_LINKING
call_and_jump->cj_label.label_object_label=code_object_label;
#endif
call_and_jump->cj_label.label_offset=CURRENT_CODE_OFFSET;
as_i_call (0);
as_branch_label (call_and_jump->cj_call_label,CALL_RELOCATION);
as_st (REGISTER_O7,0,B_STACK_POINTER);
as_i_bica (0,A_COND);
as_branch_label (&call_and_jump->cj_jump_label,BRANCH_RELOCATION);
}
void initialize_assembler (FILE *output_file_d)
{
output_file=output_file_d;
setvbuf (output_file,NULL,_IOFBF,IO_BUFFER_SIZE);
n_object_labels=1;
first_object_label=NULL;
last_object_label_l=&first_object_label;
first_code_relocation=NULL;
first_data_relocation=NULL;
last_code_relocation_l=&first_code_relocation;
last_data_relocation_l=&first_data_relocation;
n_code_relocations=0;
n_data_relocations=0;
#ifndef FUNCTION_LEVEL_LINKING
data_section_alignment_mask=3;
#endif
string_table_offset=1;
initialize_buffers();
#ifdef FUNCTION_LEVEL_LINKING
code_object_label=NULL;
n_code_sections=0;
data_object_label=NULL;
n_data_sections=0;
#else
code_object_label=fast_memory_allocate_type (struct object_label);
++n_object_labels;
*last_object_label_l=code_object_label;
last_object_label_l=&code_object_label->next;
code_object_label->next=NULL;
code_object_label->object_label_offset=0;
code_object_label->object_label_length=0;
code_object_label->object_label_kind=CODE_CONTROL_SECTION;
data_object_label=fast_memory_allocate_type (struct object_label);
++n_object_labels;
*last_object_label_l=data_object_label;
last_object_label_l=&data_object_label->next;
data_object_label->next=NULL;
data_object_label->object_label_offset=0;
data_object_label->object_label_length=0;
data_object_label->object_label_kind=DATA_CONTROL_SECTION;
data_object_label->object_section_align8=0;
#endif
}
static void as_indirect_node_entry_jump (LABEL *label)
{
long new_label_offset;
struct label *new_label;
#ifdef FUNCTION_LEVEL_LINKING
as_new_code_module();
#endif
if (label->label_flags & EA_LABEL){
int label_arity;
extern LABEL *eval_fill_label,*eval_upd_labels[];
label_arity=label->label_arity;
if (label_arity<-2)
label_arity=1;
if (label_arity>=0 && label->label_ea_label!=eval_fill_label){
as_sethi (0,REGISTER_A2);
as_hi_or_lo_label (label->label_ea_label,0,HI22_RELOCATION);
as_i_call (0);
as_branch_label (eval_upd_labels[label_arity],CALL_RELOCATION);
as_ori (REGISTER_A2,0,REGISTER_A2);
as_hi_or_lo_label (label->label_ea_label,0,LO12_RELOCATION);
} else {
as_i_call (0);
as_branch_label (label->label_ea_label,CALL_RELOCATION);
as_nop();
as_nop();
}
if (label->label_arity<0 || parallel_flag){
LABEL *descriptor_label;
descriptor_label=label->label_descriptor;
if (descriptor_label->label_id<0)
descriptor_label->label_id=next_label_id++;
store_label_in_code_section (descriptor_label);
} else
as_number_of_arguments (0);
} else
if (label->label_arity<0 || parallel_flag){
LABEL *descriptor_label;
descriptor_label=label->label_descriptor;
if (descriptor_label->label_id<0)
descriptor_label->label_id=next_label_id++;
store_label_in_code_section (descriptor_label);
}
as_number_of_arguments (label->label_arity);
new_label_offset = CURRENT_CODE_OFFSET;
new_label=allocate_memory_from_heap_type (struct label);
*new_label=*label;
as_i_call (0);
as_branch_label (new_label,CALL_RELOCATION);
label->label_id=TEXT_LABEL_ID;
#ifdef FUNCTION_LEVEL_LINKING
label->label_object_label=code_object_label;
#endif
label->label_offset=new_label_offset;
as_nop();
}
static void as_import_labels (struct label_node *label_node)
{
LABEL *label;
if (label_node==NULL)
return;
label=&label_node->label_node_label;
if (!(label->label_flags & LOCAL_LABEL) && label->label_number==0){
struct object_label *new_object_label;
int string_length;
new_object_label=fast_memory_allocate_type (struct object_label);
*last_object_label_l=new_object_label;
last_object_label_l=&new_object_label->next;
new_object_label->next=NULL;
new_object_label->object_label_label=label;
label->label_id=n_object_labels;
++n_object_labels;
label->label_offset=0;
string_length=strlen (label->label_name);
new_object_label->object_label_string_offset=string_table_offset;
string_table_offset+=string_length+1;
new_object_label->object_label_kind=IMPORTED_LABEL;
}
as_import_labels (label_node->label_node_left);
as_import_labels (label_node->label_node_right);
}
static void write_c (int c)
{
fputc (c,output_file);
}
static void write_w (int c)
{
fputc (c>>8,output_file);
fputc (c,output_file);
}
static void write_l (int c)
{
fputc (c>>24,output_file);
fputc (c>>16,output_file);
fputc (c>>8,output_file);
fputc (c,output_file);
}
static void write_zstring (char *string)
{
char c;
do {
c=*string++;
write_c (c);
} while (c!='\0');
}
#ifdef FUNCTION_LEVEL_LINKING
static int compute_section_strings_size (int string_size_without_digits,int n_sections)
{
int section_strings_size,max_n_digits,power10_max_n_digits;
section_strings_size=0;
max_n_digits=1;
power10_max_n_digits=10;
while (n_sections>power10_max_n_digits){
section_strings_size-=power10_max_n_digits;
++max_n_digits;
power10_max_n_digits*=10;
}
section_strings_size+=(string_size_without_digits+max_n_digits+1)*n_sections;
return section_strings_size;
}
static int n_digits (int n)
{
int i,power10;
i=1;
power10=10;
while (n>=power10){
++i;
power10*=10;
}
return i;
}
static int n_sections;
#endif
static void write_file_header_and_section_headers (void)
{
unsigned int offset;
#ifdef FUNCTION_LEVEL_LINKING
int n_code_relocation_sections,n_data_relocation_sections;
int section_strings_size;
n_sections=n_code_sections+n_data_sections;
{
struct object_label *object_label,*previous_code_object_label,*previous_data_object_label;
struct relocation *code_relocation,*data_relocation;
int code_offset,data_offset;
code_relocation=first_code_relocation;
code_offset=0;
n_code_relocation_sections=0;
previous_code_object_label=NULL;
data_relocation=first_data_relocation;
data_offset=0;
n_data_relocation_sections=0;
previous_data_object_label=NULL;
section_strings_size=0;
for_l (object_label,first_object_label,next){
if (object_label->object_label_kind==CODE_CONTROL_SECTION){
if (previous_code_object_label!=NULL){
int code_section_length,n_code_relocations_in_section;
code_section_length=object_label->object_label_offset-code_offset;
n_code_relocations_in_section=0;
while (code_relocation!=NULL &&
(code_relocation->relocation_offset < code_offset+code_section_length
|| (code_relocation->relocation_offset==code_offset+code_section_length && code_relocation->relocation_kind==DUMMY_BRANCH_RELOCATION)))
{
code_relocation->relocation_offset-=code_offset;
++n_code_relocations_in_section;
code_relocation=code_relocation->next;
}
previous_code_object_label->object_label_length=code_section_length;
previous_code_object_label->object_label_n_relocations=n_code_relocations_in_section;
code_offset+=code_section_length;
if (n_code_relocations_in_section>0){
section_strings_size+=13+n_digits (previous_code_object_label->object_label_section_n);
++n_code_relocation_sections;
}
}
previous_code_object_label=object_label;
} else if (object_label->object_label_kind==DATA_CONTROL_SECTION){
if (previous_data_object_label!=NULL){
int data_section_length,n_data_relocations_in_section;
data_section_length=object_label->object_label_offset-data_offset;
n_data_relocations_in_section=0;
while (data_relocation!=NULL && data_relocation->relocation_offset < data_offset+data_section_length){
data_relocation->relocation_offset-=data_offset;
++n_data_relocations_in_section;
data_relocation=data_relocation->next;
}
previous_data_object_label->object_label_length=data_section_length;
previous_data_object_label->object_label_n_relocations=n_data_relocations_in_section;
data_offset+=data_section_length;
if (n_data_relocations_in_section>0){
section_strings_size+=13+n_digits (previous_data_object_label->object_label_section_n);
++n_data_relocation_sections;
}
}
previous_data_object_label=object_label;
}
}
if (previous_code_object_label!=NULL){
int code_section_length,n_code_relocations_in_section;
code_section_length=code_buffer_offset-code_offset;
n_code_relocations_in_section=0;
while (code_relocation!=NULL){
code_relocation->relocation_offset-=code_offset;
++n_code_relocations_in_section;
code_relocation=code_relocation->next;
}
previous_code_object_label->object_label_n_relocations=n_code_relocations_in_section;
previous_code_object_label->object_label_length=code_section_length;
if (n_code_relocations_in_section>0){
section_strings_size+=13+n_digits (previous_code_object_label->object_label_section_n);
++n_code_relocation_sections;
}
}
if (previous_data_object_label!=NULL){
int data_section_length,n_data_relocations_in_section;
data_section_length=data_buffer_offset-data_offset;
n_data_relocations_in_section=0;
while (data_relocation!=NULL){
data_relocation->relocation_offset-=data_offset;
++n_data_relocations_in_section;
data_relocation=data_relocation->next;
}
previous_data_object_label->object_label_n_relocations=n_data_relocations_in_section;
previous_data_object_label->object_label_length=data_section_length;
if (n_data_relocations_in_section>0){
section_strings_size+=13+n_digits (previous_data_object_label->object_label_section_n);
++n_data_relocation_sections;
}
}
}
section_strings_size+=compute_section_strings_size (7,n_code_sections)+
compute_section_strings_size (7,n_data_sections);
#endif
/* header: */
write_l (0x7f454c46);
write_l (0x01020100);
write_l (0);
write_l (0);
write_l (0x00010002);
write_l (1);
write_l (0);
write_l (0);
write_l (0x34);
write_l (0);
write_l (0x00340000);
write_l (0x00000028);
#ifdef FUNCTION_LEVEL_LINKING
write_l (0x00000001 | ((n_sections+n_code_relocation_sections+n_data_relocation_sections+4)<<16));
#else
write_l (0x00080001);
#endif
/* offet 0x34: section header 0 */
write_l (0);
write_l (0);
write_l (0);
write_l (0);
write_l (0);
write_l (0);
write_l (0);
write_l (0);
write_l (0);
write_l (0);
#ifdef FUNCTION_LEVEL_LINKING
offset=0xd4+40*(n_sections+n_code_relocation_sections+n_data_relocation_sections);
#else
offset=0x174;
#endif
/* offset 0x5c: section header 1 */
write_l (1); /* .shstrtab offset */
write_l (SHT_STRTAB);
write_l (0);
write_l (0);
write_l (offset); /* offset */
#ifdef FUNCTION_LEVEL_LINKING
write_l ((27+section_strings_size+3) & -4);
#else
write_l (64); /* size */
#endif
write_l (0);
write_l (0);
write_l (1); /* align */
write_l (0);
#ifdef FUNCTION_LEVEL_LINKING
offset+=(27+section_strings_size+3) & -4;
#else
offset+=64;
#endif
#ifdef FUNCTION_LEVEL_LINKING
{
struct object_label *object_label;
int code_offset,data_offset,code_relocations_offset,data_relocations_offset,section_string_offset;
code_offset=0;
section_string_offset=11;
for_l (object_label,first_object_label,next){
if (object_label->object_label_kind==CODE_CONTROL_SECTION){
int code_section_length;
code_section_length=object_label->object_label_length;
write_l (section_string_offset);
write_l (SHT_PROGBITS);
write_l (SHF_ALLOC | SHF_EXECINSTR);
write_l (0);
write_l (offset+code_offset);
write_l (code_section_length);
write_l (0);
write_l (0);
write_l (4);
write_l (0);
section_string_offset+=8+n_digits (object_label->object_label_section_n);
code_offset+=code_section_length;
}
}
offset+=(code_offset+3) & -4;
data_offset=0;
for_l (object_label,first_object_label,next){
if (object_label->object_label_kind==DATA_CONTROL_SECTION){
int data_section_length;
data_section_length=object_label->object_label_length;
write_l (section_string_offset);
write_l (SHT_PROGBITS);
write_l (SHF_ALLOC | SHF_WRITE);
write_l (0);
write_l (offset+data_offset);
write_l (data_section_length);
write_l (0);
write_l (0);
write_l (object_label->object_section_align8 ? 8 : 4);
write_l (0);
section_string_offset+=8+n_digits (object_label->object_label_section_n);
data_offset+=data_section_length;
}
}
offset+=(data_offset+3) & -4;
code_relocations_offset=0;
for_l (object_label,first_object_label,next){
if (object_label->object_label_kind==CODE_CONTROL_SECTION){
int n_code_relocations_in_section;
n_code_relocations_in_section=object_label->object_label_n_relocations;
if (n_code_relocations_in_section>0){
write_l (section_string_offset);
write_l (SHT_RELA);
write_l (0);
write_l (0);
write_l (offset+code_relocations_offset);
write_l (12*n_code_relocations_in_section);
write_l (n_sections+n_code_relocation_sections+n_data_relocation_sections+2);
write_l (2+object_label->object_label_section_n);
write_l (4);
write_l (12);
section_string_offset+=13+n_digits (object_label->object_label_section_n);
code_relocations_offset+=12*n_code_relocations_in_section;
}
}
}
offset+=12*n_code_relocations;
data_relocations_offset=0;
for_l (object_label,first_object_label,next){
if (object_label->object_label_kind==DATA_CONTROL_SECTION){
int n_data_relocations_in_section;
n_data_relocations_in_section=object_label->object_label_n_relocations;
if (n_data_relocations_in_section>0){
write_l (section_string_offset);
write_l (SHT_RELA);
write_l (0);
write_l (0);
write_l (offset+data_relocations_offset);
write_l (12*n_data_relocations_in_section);
write_l (n_sections+n_code_relocation_sections+n_data_relocation_sections+2);
write_l (2+n_code_sections+object_label->object_label_section_n);
write_l (4);
write_l (12);
section_string_offset+=13+n_digits (object_label->object_label_section_n);
data_relocations_offset+=12*n_data_relocations_in_section;
}
}
}
offset+=12*n_data_relocations;
}
#else
/* offset 0x84: section header 2 */
write_l (11); /* .text offset */
write_l (SHT_PROGBITS);
write_l (SHF_ALLOC | SHF_EXECINSTR);
write_l (0);
write_l (offset);
write_l (code_buffer_offset); /* size */
write_l (0);
write_l (0);
write_l (4); /* align */
write_l (0);
offset+=code_buffer_offset;
/* offset 0xac: section header 3 */
write_l (17); /* .data offset */
write_l (SHT_PROGBITS);
write_l (SHF_ALLOC | SHF_WRITE);
write_l (0);
write_l (offset);
write_l (data_buffer_offset); /* size */
write_l (0);
write_l (0);
write_l (data_section_alignment_mask+1); /* align */
write_l (0);
offset+=data_buffer_offset;
/* offet 0xd4: section header 4 */
write_l (23); /* .rela.text offset */
write_l (SHT_RELA);
write_l (0);
write_l (0);
write_l (offset);
write_l (12*n_code_relocations); /* size */
write_l (6); /* symbol table index */
write_l (2); /* text section index */
write_l (4); /* align */
write_l (12);
offset+=12*n_code_relocations;
/* offset 0xfc: section header 5 */
write_l (34); /* .rela.data offset */
write_l (SHT_RELA);
write_l (0);
write_l (0);
write_l (offset);
write_l (12*n_data_relocations); /* size */
write_l (6); /* symbol table index */
write_l (3); /* data section index */
write_l (4); /* align */
write_l (12);
offset+=12*n_data_relocations;
#endif
/* offset 0x124: section header 6 */
#ifdef FUNCTION_LEVEL_LINKING
write_l (11+section_strings_size);
#else
write_l (45); /* .symtab offset */
#endif
write_l (SHT_SYMTAB);
write_l (0);
write_l (0);
write_l (offset);
write_l (16*(n_object_labels+n_sections));
#ifdef FUNCTION_LEVEL_LINKING
write_l (n_sections+n_code_relocation_sections+n_data_relocation_sections+3);
write_l (1+n_sections);
#else
write_l (7); /* string table index */
write_l (3);
#endif
write_l (4); /* align */
write_l (16);
offset+=16*(n_object_labels+n_sections);
/* offset 0x14c: section header 7 */
#ifdef FUNCTION_LEVEL_LINKING
write_l (19+section_strings_size);
#else
write_l (53); /* .strtab offset */
#endif
write_l (SHT_STRTAB);
write_l (0);
write_l (0);
write_l (offset);
write_l (string_table_offset); /* size */
write_l (0);
write_l (0);
write_l (0); /* align */
write_l (0);
/* offset 0x174: section 1 */
write_c (0);
write_zstring (".shstrtab"); /* 1 */
#ifdef FUNCTION_LEVEL_LINKING
{
struct object_label *object_label;
int section_n;
char section_name[20];
for (section_n=0; section_n<n_code_sections; ++section_n){
sprintf (section_name,".text.m%d",section_n);
write_zstring (section_name);
}
for (section_n=0; section_n<n_data_sections; ++section_n){
sprintf (section_name,".data.m%d",section_n);
write_zstring (section_name);
}
for_l (object_label,first_object_label,next)
if (object_label->object_label_kind==CODE_CONTROL_SECTION && object_label->object_label_n_relocations>0){
sprintf (section_name,".rela.text.m%d",object_label->object_label_section_n);
write_zstring (section_name);
}
for_l (object_label,first_object_label,next)
if (object_label->object_label_kind==DATA_CONTROL_SECTION && object_label->object_label_n_relocations>0){
sprintf (section_name,".rela.data.m%d",object_label->object_label_section_n);
write_zstring (section_name);
}
}
#else
write_zstring (".text"); /* 11 */
write_zstring (".data"); /* 17 */
write_zstring (".rela.text");/* 23 */
write_zstring (".rela.data");/* 34 */
#endif
write_zstring (".symtab"); /* 45 */
write_zstring (".strtab"); /* 53 */
/* 61 */
#ifdef FUNCTION_LEVEL_LINKING
if (((27+section_strings_size) & 3)!=0){
int n;
n=4-((27+section_strings_size) & 3);
do {
write_c (0);
} while (--n);
}
#else
write_c (0);
write_c (0);
write_c (0);
/* offset 0x1b4 */
#endif
}
static void as_indirect_node_entry_jumps (struct label_node *label_node)
{
LABEL *label;
if (label_node==NULL)
return;
label=&label_node->label_node_label;
if (!(label->label_flags & LOCAL_LABEL) && label->label_number==0)
if (label->label_flags & NODE_ENTRY_LABEL)
as_indirect_node_entry_jump (label);
as_indirect_node_entry_jumps (label_node->label_node_left);
as_indirect_node_entry_jumps (label_node->label_node_right);
}
void write_code (void)
{
struct basic_block *block;
struct call_and_jump *call_and_jump;
first_call_and_jump=NULL;
as_indirect_node_entry_jumps (labels);
#ifdef FUNCTION_LEVEL_LINKING
if (first_block!=NULL && !(first_block->block_begin_module && !first_block->block_link_module))
first_block->block_begin_module=1;
#endif
for_l (block,first_block,block_next){
#ifdef FUNCTION_LEVEL_LINKING
if (block->block_begin_module){
if (block->block_link_module){
if (code_object_label!=NULL && CURRENT_CODE_OFFSET!=code_object_label->object_label_offset && block->block_labels){
struct relocation *new_relocation;
new_relocation=fast_memory_allocate_type (struct relocation);
++n_code_relocations;
*last_code_relocation_l=new_relocation;
last_code_relocation_l=&new_relocation->next;
new_relocation->next=NULL;
U5 (new_relocation,
relocation_label=block->block_labels->block_label_label,
relocation_offset=CURRENT_CODE_OFFSET,
relocation_object_label=code_object_label,
relocation_kind=DUMMY_BRANCH_RELOCATION,
relocation_addend=0);
as_new_code_module();
}
} else
as_new_code_module();
}
#endif
if (block->block_n_node_arguments>-100){
if (block->block_ea_label!=NULL){
int n_node_arguments;
extern LABEL *eval_fill_label,*eval_upd_labels[];
n_node_arguments=block->block_n_node_arguments;
if (n_node_arguments<-2)
n_node_arguments=1;
if (n_node_arguments>=0 && block->block_ea_label!=eval_fill_label){
as_sethi (0,REGISTER_A2);
as_hi_or_lo_label (block->block_ea_label,0,HI22_RELOCATION);
as_i_call (0);
as_branch_label (eval_upd_labels[n_node_arguments],CALL_RELOCATION);
as_ori (REGISTER_A2,0,REGISTER_A2);
as_hi_or_lo_label (block->block_ea_label,0,LO12_RELOCATION);
} else {
as_i_call (0);
as_branch_label (block->block_ea_label,CALL_RELOCATION);
as_nop();
as_nop();
}
if (block->block_descriptor!=NULL && (block->block_n_node_arguments<0 || parallel_flag)){
store_label_in_code_section (block->block_descriptor);
} else
as_number_of_arguments (0);
} else
if (block->block_descriptor!=NULL)
store_label_in_code_section (block->block_descriptor);
else
as_number_of_arguments (0);
as_number_of_arguments (block->block_n_node_arguments);
}
as_labels (block->block_labels);
if (block->block_n_new_heap_cells>0)
as_garbage_collect_test (block);
as_instructions (block->block_instructions);
}
for (call_and_jump=first_call_and_jump; call_and_jump!=NULL; call_and_jump=call_and_jump->cj_next){
#ifdef FUNCTION_LEVEL_LINKING
as_new_code_module();
#endif
as_call_and_jump (call_and_jump);
}
#ifndef FUNCTION_LEVEL_LINKING
as_nop();
#endif
}
static void relocate_code (void)
{
struct relocation *relocation,**relocation_p;
struct object_buffer *object_buffer;
int buffer_offset;
struct label *label;
int instruction_offset;
ULONG *instruction_p;
object_buffer=first_code_buffer;
buffer_offset=0;
relocation_p=&first_code_relocation;
while (relocation=*relocation_p,relocation!=NULL){
label=relocation->relocation_label;
switch (relocation->relocation_kind){
case BRANCH_RELOCATION:
if (label->label_id==TEXT_LABEL_ID
#ifdef FUNCTION_LEVEL_LINKING
&& label->label_object_label==relocation->relocation_object_label
#endif
){
instruction_offset=relocation->relocation_offset;
while (instruction_offset >= buffer_offset+BUFFER_SIZE){
object_buffer=object_buffer->next;
buffer_offset+=BUFFER_SIZE;
}
instruction_p=(ULONG*)((char*)(object_buffer->data)+(instruction_offset-buffer_offset));
*instruction_p= ((*instruction_p)& 0xffc00000) | (((label->label_offset-instruction_offset+relocation->relocation_addend)>>2) & 0x3fffff);
*relocation_p=relocation->next;
--n_code_relocations;
continue;
}
#ifdef FUNCTION_LEVEL_LINKING
else if (label->label_id==TEXT_LABEL_ID || label->label_id==DATA_LABEL_ID){
if (label->label_object_label==NULL)
internal_error_in_function ("relocate_code");
relocation->relocation_addend -= label->label_object_label->object_label_offset;
}
#endif
break;
case CALL_RELOCATION:
if (label->label_id==TEXT_LABEL_ID
#ifdef FUNCTION_LEVEL_LINKING
&& label->label_object_label==relocation->relocation_object_label
#endif
){
instruction_offset=relocation->relocation_offset;
while (instruction_offset >= buffer_offset+BUFFER_SIZE){
object_buffer=object_buffer->next;
buffer_offset+=BUFFER_SIZE;
}
instruction_p=(ULONG*)((char*)(object_buffer->data)+(instruction_offset-buffer_offset));
*instruction_p= ((*instruction_p)& 0xc0000000) | (((label->label_offset-instruction_offset+relocation->relocation_addend)>>2) & 0x3fffffff);
*relocation_p=relocation->next;
--n_code_relocations;
continue;
}
#ifdef FUNCTION_LEVEL_LINKING
else if (label->label_id==TEXT_LABEL_ID || label->label_id==DATA_LABEL_ID){
if (label->label_object_label==NULL)
internal_error_in_function ("relocate_code");
relocation->relocation_addend -= label->label_object_label->object_label_offset;
}
#endif
break;
#ifdef FUNCTION_LEVEL_LINKING
case HI22_RELOCATION:
case LO12_RELOCATION:
case LONG_WORD_RELOCATION:
if (label->label_id==TEXT_LABEL_ID || label->label_id==DATA_LABEL_ID){
if (label->label_object_label==NULL)
internal_error_in_function ("relocate_code");
relocation->relocation_addend -= label->label_object_label->object_label_offset;
}
break;
case DUMMY_BRANCH_RELOCATION:
if (label->label_id==TEXT_LABEL_ID){
if (label->label_object_label!=relocation->relocation_object_label){
relocation->relocation_addend -= label->label_object_label->object_label_offset;
relocation_p=&relocation->next;
} else {
*relocation_p=relocation->next;
--n_code_relocations;
}
continue;
} else {
internal_error_in_function ("relocate_code");
*relocation_p=relocation->next;
}
#endif
}
relocation_p=&relocation->next;
}
}
static void relocate_data (void)
{
#ifdef FUNCTION_LEVEL_LINKING
struct relocation *relocation;
for_l (relocation,first_data_relocation,next){
switch (relocation->relocation_kind){
case LONG_WORD_RELOCATION:
{
struct label *label;
label=relocation->relocation_label;
if (label->label_id==TEXT_LABEL_ID || label->label_id==DATA_LABEL_ID){
if (label->label_object_label==NULL)
internal_error_in_function ("relocate_data");
relocation->relocation_addend -= label->label_object_label->object_label_offset;
}
}
}
}
#endif
}
#ifdef FUNCTION_LEVEL_LINKING
static int elf_label_number (struct label *label)
{
int label_n;
label_n=label->label_id;
if (label_n==TEXT_LABEL_ID){
label_n=label->label_object_label->object_label_number;
if (label_n==0)
return 1+label->label_object_label->object_label_section_n;
else
return label_n+n_sections;
} else if (label_n==DATA_LABEL_ID){
label_n=label->label_object_label->object_label_number;
if (label_n==0)
return 1+n_code_sections+label->label_object_label->object_label_section_n;
else
return label_n+n_sections;
} else {
if (label_n==-1)
internal_error_in_function ("elf_label_number");
return label_n+n_sections;
}
}
#endif
static void write_code_relocations (void)
{
struct relocation *relocation;
for_l (relocation,first_code_relocation,next){
struct label *label;
label=relocation->relocation_label;
switch (relocation->relocation_kind){
case BRANCH_RELOCATION:
write_l (relocation->relocation_offset);
#ifdef FUNCTION_LEVEL_LINKING
write_l (ELF32_R_INFO (elf_label_number (label),R_SPARC_WDISP22));
#else
write_l (ELF32_R_INFO (label->label_id,R_SPARC_WDISP22));
#endif
write_l (relocation->relocation_addend+label->label_offset);
break;
case CALL_RELOCATION:
write_l (relocation->relocation_offset);
#ifdef FUNCTION_LEVEL_LINKING
write_l (ELF32_R_INFO (elf_label_number (label),R_SPARC_WDISP30));
#else
write_l (ELF32_R_INFO (label->label_id,R_SPARC_WDISP30));
#endif
write_l (relocation->relocation_addend+label->label_offset);
break;
case HI22_RELOCATION:
write_l (relocation->relocation_offset);
#ifdef FUNCTION_LEVEL_LINKING
write_l (ELF32_R_INFO (elf_label_number (label),R_SPARC_HI22));
#else
write_l (ELF32_R_INFO (label->label_id,R_SPARC_HI22));
#endif
write_l (relocation->relocation_addend+label->label_offset);
break;
case LO12_RELOCATION:
write_l (relocation->relocation_offset);
#ifdef FUNCTION_LEVEL_LINKING
write_l (ELF32_R_INFO (elf_label_number (label),R_SPARC_LO10));
#else
write_l (ELF32_R_INFO (label->label_id,R_SPARC_LO10));
#endif
write_l (relocation->relocation_addend+label->label_offset);
break;
case LONG_WORD_RELOCATION:
write_l (relocation->relocation_offset);
#ifdef FUNCTION_LEVEL_LINKING
write_l (ELF32_R_INFO (elf_label_number (label),R_SPARC_32));
#else
write_l (ELF32_R_INFO (label->label_id,R_SPARC_32));
#endif
write_l (relocation->relocation_addend+label->label_offset);
break;
case DUMMY_BRANCH_RELOCATION:
write_l (relocation->relocation_offset);
#ifdef FUNCTION_LEVEL_LINKING
write_l (ELF32_R_INFO (elf_label_number (label),R_SPARC_NONE));
#else
write_l (ELF32_R_INFO (label->label_id,R_SPARC_NONE));
#endif
write_l (relocation->relocation_addend+label->label_offset);
break;
default:
internal_error_in_function ("write_code_relocations");
}
}
}
static void write_data_relocations (void)
{
struct relocation *relocation;
for_l (relocation,first_data_relocation,next){
struct label *label;
label=relocation->relocation_label;
switch (relocation->relocation_kind){
case LONG_WORD_RELOCATION:
write_l (relocation->relocation_offset);
#ifdef FUNCTION_LEVEL_LINKING
write_l (ELF32_R_INFO (elf_label_number (label),R_SPARC_32));
#else
write_l (ELF32_R_INFO (label->label_id,R_SPARC_32));
#endif
write_l (relocation->relocation_addend+label->label_offset);
break;
default:
internal_error_in_function ("write_data_relocations");
}
}
}
static void write_object_labels (void)
{
struct object_label *object_label;
int code_section_number,data_section_number;
#if defined (RELOCATIONS_RELATIVE_TO_EXPORTED_DATA_LABEL) && defined (FUNCTION_LEVEL_LINKING)
struct object_label *current_text_or_data_object_label;
current_text_or_data_object_label=NULL;
#endif
code_section_number=0;
data_section_number=0;
write_l (0);
write_l (0);
write_l (0);
write_l (0);
# ifndef FUNCTION_LEVEL_LINKING
write_l (0);
write_l (0);
write_l (0);
write_c (ELF32_ST_INFO (STB_LOCAL,STT_SECTION));
write_c (0);
write_w (2);
write_l (0);
write_l (0);
write_l (0);
write_c (ELF32_ST_INFO (STB_LOCAL,STT_SECTION));
write_c (0);
write_w (3);
#else
{
int section_n;
for (section_n=0; section_n<n_code_sections; ++section_n){
write_l (0);
write_l (0);
write_l (0);
write_c (ELF32_ST_INFO (STB_LOCAL,STT_SECTION));
write_c (0);
write_w (2+section_n);
}
for (section_n=0; section_n<n_data_sections; ++section_n){
write_l (0);
write_l (0);
write_l (0);
write_c (ELF32_ST_INFO (STB_LOCAL,STT_SECTION));
write_c (0);
write_w (2+n_code_sections+section_n);
}
}
# endif
for_l (object_label,first_object_label,next){
switch (object_label->object_label_kind){
case CODE_CONTROL_SECTION:
break;
case DATA_CONTROL_SECTION:
#if defined (RELOCATIONS_RELATIVE_TO_EXPORTED_DATA_LABEL) && defined (FUNCTION_LEVEL_LINKING)
current_text_or_data_object_label=object_label;
#endif
break;
case IMPORTED_LABEL:
write_l (object_label->object_label_string_offset);
write_l (0);
write_l (0);
write_c (ELF32_ST_INFO (STB_GLOBAL,STT_NOTYPE));
write_c (0);
write_w (0);
break;
case EXPORTED_CODE_LABEL:
{
struct label *label;
label=object_label->object_label_label;
write_l (object_label->object_label_string_offset);
#ifdef FUNCTION_LEVEL_LINKING
write_l (label->label_offset - label->label_object_label->object_label_offset);
#else
write_l (label->label_offset);
#endif
write_l (0);
write_c (ELF32_ST_INFO (STB_GLOBAL,STT_FUNC));
write_c (0);
#ifdef FUNCTION_LEVEL_LINKING
write_w (2+label->label_object_label->object_label_section_n);
#else
write_w (2);
#endif
break;
}
case EXPORTED_DATA_LABEL:
{
struct label *label;
label=object_label->object_label_label;
write_l (object_label->object_label_string_offset);
#ifdef FUNCTION_LEVEL_LINKING
# ifdef RELOCATIONS_RELATIVE_TO_EXPORTED_DATA_LABEL
write_l (label->label_offset - current_text_or_data_object_label->object_label_offset);
# else
write_l (label->label_offset - label->label_object_label->object_label_offset);
#endif
#else
write_l (label->label_offset);
#endif
write_l (0);
write_c (ELF32_ST_INFO (STB_GLOBAL,STT_OBJECT));
write_c (0);
#ifdef FUNCTION_LEVEL_LINKING
write_w (2+n_code_sections+label->label_object_label->object_label_section_n);
#else
write_w (3);
#endif
break;
}
default:
internal_error_in_function ("write_object_labels");
}
}
}
static void write_string_table (void)
{
struct object_label *object_label;
write_c (0);
for_l (object_label,first_object_label,next){
int object_label_kind;
object_label_kind=object_label->object_label_kind;
if ((object_label_kind==IMPORTED_LABEL || object_label_kind==EXPORTED_CODE_LABEL || object_label_kind==EXPORTED_DATA_LABEL)
&& object_label->object_label_string_offset!=0)
{
char *s,c;
s=object_label->object_label_label->label_name;
do {
c=*s++;
write_c (c);
} while (c!='\0');
}
}
}
void assemble_code (void)
{
as_import_labels (labels);
write_code();
flush_data_buffer();
flush_code_buffer();
#ifndef FUNCTION_LEVEL_LINKING
code_object_label->object_label_length=code_buffer_offset;
data_object_label->object_label_length=data_buffer_offset;
#endif
relocate_code();
relocate_data();
write_file_header_and_section_headers();
write_buffers_and_release_memory (&first_code_buffer);
write_buffers_and_release_memory (&first_data_buffer);
write_code_relocations();
write_data_relocations();
write_object_labels();
write_string_table();
}
