~ubuntu-branches/ubuntu/utopic/binutils-arm64-cross/utopic

s3_inst.instruction |= ((s3_inst.reloc.exp.X_add_number>>1) & 0x1) | ((s3_inst.reloc.exp.X_add_number>>2) & 0x7)<<7 |((s3_inst.reloc.exp.X_add_number>>5) & 0x1f)<<20;

4683

4684

/* Check and set offset. */

4685

if (((val & 0xfffffe00) != 0)

4686

&& ((val & 0xfffffe00) != 0xfffffe00))

4687

{

4688

if (s3_score_pic == s3_NO_PIC)

4689

{

4690

sprintf (&append_str[0], "cmpi! r%d,0", reg_a);

4691

if (s3_append_insn (&append_str[0], TRUE) == (int) s3_FAIL)

4692

return;

4693

if ((inst_main.instruction & 0x3e00007e) == 0x0000004c)

4694

sprintf (&append_str[1], "beq %s", keep_data);

4695

else

4696

sprintf (&append_str[1], "bne %s", keep_data);

4697

if (s3_append_insn (&append_str[1], TRUE) == (int) s3_FAIL)

4698

return;

4699

}

4700

else

4701

{

4702

gas_assert (s3_inst.reloc.exp.X_add_symbol);

4703

}

4704

/* Set bwarn as -1, so macro instruction itself will not be generated frag. */

4705

s3_inst.bwarn = -1;

4706

return;

4707

}

4708

else

4709

{

4710

val >>= 1;

4711

s3_inst.instruction |= (val & 0x1)

4712

| (((val >> 1) & 0x7) << 7)

4713

| (((val >> 4) & 0x1f) << 20);

4714

}

4715

4716

/* Backup s3_inst. */

4717

memcpy (&inst_main, &s3_inst, sizeof (struct s3_score_it));

4718

4719

if (s3_score_pic == s3_NO_PIC)

4720

{

4721

sprintf (&append_str[0], "cmpi! r%d, 0", reg_a);

4722

if (s3_append_insn (&append_str[0], FALSE) == (int) s3_FAIL)

4723

return;

4724

memcpy (&inst_expand[0], &s3_inst, sizeof (struct s3_score_it));

4725

if ((inst_main.instruction & 0x3e00007e) == 0x0000004c)

4726

sprintf (&append_str[1], "beq %s", keep_data);

4727

else

4728

sprintf (&append_str[1], "bne %s", keep_data);

4729

if (s3_append_insn (&append_str[1], FALSE) == (int) s3_FAIL)

4730

return;

4731

memcpy (&inst_expand[1], &s3_inst, sizeof (struct s3_score_it));

4732

}

4733

else

4734

{

4735

gas_assert (s3_inst.reloc.exp.X_add_symbol);

4736

}

4737

inst_main.relax_size = inst_expand[0].size + inst_expand[1].size;

4738

inst_main.type = Insn_BCMP;

4739

4740

/* Adjust instruction opcode and to be relaxed instruction opcode. */

4741

inst_main.instruction = s3_adjust_paritybit (inst_main.instruction, s3_GET_INSN_CLASS (inst_main.type));

4742

4743

for (i = 0; i < 2; i++)

4744

inst_expand[i].instruction = s3_adjust_paritybit (inst_expand[i].instruction ,

4745

s3_GET_INSN_CLASS (inst_expand[i].type));

4746

/* Check data dependency. */

4747

s3_handle_dependency (&inst_main);

4748

/* Start a new frag if frag_now is not empty. */

4749

if (frag_now_fix () != 0)

4750

{

4751

if (!frag_now->tc_frag_data.is_insn)

4752

frag_wane (frag_now);

4753

frag_new (0);

4754

}

4755

frag_grow (20);

4756

4757

/* Write fr_fix part. */

4758

char *p;

4759

p = frag_more (inst_main.size);

4760

s3_md_number_to_chars (p, inst_main.instruction, inst_main.size);

4761

4762

if (inst_main.reloc.type != BFD_RELOC_NONE)

4763

{

4764

s3_fix_new_score (frag_now, p - frag_now->fr_literal, inst_main.size,

4765

&inst_main.reloc.exp, inst_main.reloc.pc_rel, inst_main.reloc.type);

4766

}

4767

#ifdef OBJ_ELF

4768

dwarf2_emit_insn (inst_main.size);

4769

#endif

4770

4771

/* s3_GP instruction can not do optimization, only can do relax between

4772

1 instruction and 3 instructions. */

4773

p = frag_var (rs_machine_dependent, inst_main.relax_size + s3_RELAX_PAD_BYTE, 0,

4774

s3_RELAX_ENCODE (inst_main.size, inst_main.relax_size, inst_main.type, 0, 4, 1),

4775

inst_main.reloc.exp.X_add_symbol, 0, NULL);

4776

4777

/* Write fr_var part.

4778

no calling s3_gen_insn_frag, no fixS will be generated. */

4779

s3_md_number_to_chars (p, inst_expand[0].instruction, inst_expand[0].size);

4780

p += inst_expand[0].size;

4781

s3_md_number_to_chars (p, inst_expand[1].instruction, inst_expand[1].size);

4782

p += inst_expand[1].size;

4783

4784

/* Set bwarn as -1, so macro instruction itself will not be generated frag. */

4785

s3_inst.bwarn = -1;

4786

}

4787

}

4788

4789

static int

4790

s3_nopic_need_relax (symbolS * sym, int before_relaxing)

4791

{

4792

if (sym == NULL)

4793

return 0;

4794

else if (s3_USE_GLOBAL_POINTER_OPT && s3_g_switch_value > 0)

4795

{

4796

const char *symname;

4797

const char *segname;

4798

4799

/* Find out whether this symbol can be referenced off the $gp

4800

4801

it is in the .sdata or .sbss section. Certain symbols can

4802

not be referenced off the $gp, although it appears as though

4803

they can. */

4804

symname = S_GET_NAME (sym);

4805

if (symname != (const char *)NULL

4806

&& (strcmp (symname, "eprol") == 0

4807

|| strcmp (symname, "etext") == 0

4808

|| strcmp (symname, "_gp") == 0

4809

|| strcmp (symname, "edata") == 0

4810

|| strcmp (symname, "_fbss") == 0

4811

|| strcmp (symname, "_fdata") == 0

4812

|| strcmp (symname, "_ftext") == 0

4813

|| strcmp (symname, "end") == 0

4814

|| strcmp (symname, GP_DISP_LABEL) == 0))

4815

{

4816

return 1;

4817

}

4818

else if ((!S_IS_DEFINED (sym) || S_IS_COMMON (sym)) && (0

4819

/* We must defer this decision until after the whole file has been read,

4820

since there might be a .extern after the first use of this symbol. */

4821

|| (before_relaxing

4822

&& S_GET_VALUE (sym) == 0)

4823

|| (S_GET_VALUE (sym) != 0

4824

&& S_GET_VALUE (sym) <= s3_g_switch_value)))

4825

{

4826

return 0;

4827

}

4828

4829

segname = segment_name (S_GET_SEGMENT (sym));

4830

return (strcmp (segname, ".sdata") != 0

4831

&& strcmp (segname, ".sbss") != 0

4832

&& strncmp (segname, ".sdata.", 7) != 0

4833

&& strncmp (segname, ".gnu.linkonce.s.", 16) != 0);

4834

}

4835

/* We are not optimizing for the $gp register. */

4836

else

4837

return 1;

4838

}

4839

4840

/* Build a relax frag for lw/st instruction when generating s3_PIC,

4841

external symbol first and local symbol second. */

4842

static void

4843

s3_build_lwst_pic (int reg_rd, expressionS exp, const char *insn_name)

4844

{

4845

symbolS *add_symbol = exp.X_add_symbol;

4846

int add_number = exp.X_add_number;

4847

struct s3_score_it fix_insts[s3_RELAX_INST_NUM];

4848

struct s3_score_it var_insts[s3_RELAX_INST_NUM];

4849

int fix_num = 0;

4850

int var_num = 0;

4851

char tmp[s3_MAX_LITERAL_POOL_SIZE];

4852

int r1_bak;

4853

4854

r1_bak = s3_nor1;

4855

s3_nor1 = 0;

4856

4857

if ((add_number == 0) || (add_number >= -0x8000 && add_number <= 0x7fff))

4858

{

4859

fix_num = 1;

4860

var_num = 2;

4861

4862

/* For an external symbol, two insns are generated;

4863

For a local symbol, three insns are generated. */

4864

/* Fix part

4865

For an external symbol: lw rD, <sym>($gp)

4866

(BFD_RELOC_SCORE_GOT15) */

4867

sprintf (tmp, "lw_pic r1, %s", add_symbol->bsym->name);

4868

if (s3_append_insn (tmp, FALSE) == (int) s3_FAIL)

4869

return;

4870

4871

memcpy (&fix_insts[0], &s3_inst, sizeof (struct s3_score_it));

4872

4873

/* Var part

4874

For a local symbol :

4875

lw rD, <sym>($gp) (BFD_RELOC_SCORE_GOT15)

4876

addi rD, <sym> (BFD_RELOC_GOT_LO16) */

4877

s3_inst.reloc.type = BFD_RELOC_SCORE_GOT15;

4878

memcpy (&var_insts[0], &s3_inst, sizeof (struct s3_score_it));

4879

sprintf (tmp, "addi_s_pic r1, %s", add_symbol->bsym->name);

4880

if (s3_append_insn (tmp, FALSE) == (int) s3_FAIL)

4881

return;

4882

4883

memcpy (&var_insts[1], &s3_inst, sizeof (struct s3_score_it));

4884

s3_build_relax_frag (fix_insts, fix_num, var_insts, var_num, add_symbol);

4885

4886

/* Insn 2 or Insn 3: lw/st rD, [r1, constant] */

4887

sprintf (tmp, "%s r%d, [r1, %d]", insn_name, reg_rd, add_number);

4888

if (s3_append_insn (tmp, TRUE) == (int) s3_FAIL)

4889

return;

4890

4891

/* Set bwarn as -1, so macro instruction itself will not be generated frag. */

4892

s3_inst.bwarn = -1;

4893

}

4894

else

4895

{

4896

s3_inst.error = _("s3_PIC code offset overflow (max 16 signed bits)");

4897

return;

4898

}

4899

4900

s3_nor1 = r1_bak;

4901

}

4902

4903

static void

4904

s3_do_macro_ldst_label (char *str)

4905

{

4906

int i;

4907

int ldst_gp_p = 0;

4908

int reg_rd;

4909

int r1_bak;

4910

char *backup_str;

4911

char *label_str;

4912

char *absolute_value;

4913

char append_str[3][s3_MAX_LITERAL_POOL_SIZE];

4914

char verifystr[s3_MAX_LITERAL_POOL_SIZE];

4915

struct s3_score_it inst_backup;

4916

struct s3_score_it inst_expand[3];

4917

struct s3_score_it inst_main;

4918

4919

memcpy (&inst_backup, &s3_inst, sizeof (struct s3_score_it));

4920

strcpy (verifystr, str);

4921

backup_str = verifystr;

4922

4923

s3_skip_whitespace (backup_str);

4924

if ((reg_rd = s3_reg_required_here (&backup_str, -1, s3_REG_TYPE_SCORE)) == (int) s3_FAIL)

4925

return;

4926

4927

if (s3_skip_past_comma (&backup_str) == (int) s3_FAIL)

4928

return;

4929

4930

label_str = backup_str;

4931

4932

/* Ld/st rD, [rA, imm] ld/st rD, [rA]+, imm ld/st rD, [rA, imm]+. */

4933

if (*backup_str == '[')

4934

{

4935

s3_inst.type = Rd_rvalueRs_preSI12;

4936

s3_do_ldst_insn (str);

4937

return;

4938

}

4939

4940

/* Ld/st rD, imm. */

4941

absolute_value = backup_str;

4942

s3_inst.type = Rd_rvalueRs_SI15;

4943

4944

if (s3_my_get_expression (&s3_inst.reloc.exp, &backup_str) == (int) s3_FAIL)

4945

{

4946

s3_inst.error = _("expression error");

4947

return;

4948

}

4949

else if ((s3_inst.reloc.exp.X_add_symbol == NULL)

4950

&& (s3_validate_immediate (s3_inst.reloc.exp.X_add_number, _VALUE, 0) == (int) s3_FAIL))

4951

{

4952

s3_inst.error = _("value not in range [0, 0x7fffffff]");

4953

return;

4954

}

4955

else if (s3_end_of_line (backup_str) == (int) s3_FAIL)

4956

{

4957

s3_inst.error = _("end on line error");

4958

return;

4959

}

4960

else

4961

{

4962

if (s3_inst.reloc.exp.X_add_symbol == 0)

4963

{

4964

memcpy (&s3_inst, &inst_backup, sizeof (struct s3_score_it));

4965

s3_exp_macro_ldst_abs (str);

4966

return;

4967

}

4968

}

4969

4970

/* Ld/st rD, label. */

4971

s3_inst.type = Rd_rvalueRs_SI15;

4972

backup_str = absolute_value;

4973

if ((s3_data_op2 (&backup_str, 1, _GP_IMM15) == (int) s3_FAIL)

4974

|| (s3_end_of_line (backup_str) == (int) s3_FAIL))

4975

{

4976

return;

4977

}

4978

else

4979

{

4980

if (s3_inst.reloc.exp.X_add_symbol == 0)

4981

{

4982

if (!s3_inst.error)

4983

s3_inst.error = s3_BAD_ARGS;

4984

4985

return;

4986

}

4987

4988

if (s3_score_pic == s3_PIC)

4989

{

4990

int ldst_idx = 0;

4991

ldst_idx = s3_inst.instruction & OPC_PSEUDOLDST_MASK;

4992

s3_build_lwst_pic (reg_rd, s3_inst.reloc.exp,

4993

s3_score_ldst_insns[ldst_idx * 3 + 0].template_name);

4994

return;

4995

}

4996

else

4997

{

4998

if ((s3_inst.reloc.exp.X_add_number <= 0x3fff)

4999

&& (s3_inst.reloc.exp.X_add_number >= -0x4000)

5000

&& (!s3_nopic_need_relax (s3_inst.reloc.exp.X_add_symbol, 1)))

5001

{

5002

int ldst_idx = 0;

5003

5004

/* Assign the real opcode. */

5005

ldst_idx = s3_inst.instruction & OPC_PSEUDOLDST_MASK;

5006

s3_inst.instruction &= ~OPC_PSEUDOLDST_MASK;

5007

s3_inst.instruction |= s3_score_ldst_insns[ldst_idx * 3 + 0].value;

5008

s3_inst.instruction |= reg_rd << 20;

5009

s3_inst.instruction |= s3_GP << 15;

5010

s3_inst.relax_inst = 0x8000;

5011

s3_inst.relax_size = 0;

5012

ldst_gp_p = 1;

5013

}

5014

}

5015

}

5016

5017

/* Backup s3_inst. */

5018

memcpy (&inst_main, &s3_inst, sizeof (struct s3_score_it));

5019

r1_bak = s3_nor1;

5020

s3_nor1 = 0;

5021

5022

/* Determine which instructions should be output. */

5023

sprintf (append_str[0], "ld_i32hi r1, %s", label_str);

5024

sprintf (append_str[1], "ld_i32lo r1, %s", label_str);

5025

sprintf (append_str[2], "%s r%d, [r1, 0]", inst_backup.name, reg_rd);

5026

5027

/* Generate three instructions.

5028

la r1, label

5029

ld/st rd, [r1, 0] */

5030

for (i = 0; i < 3; i++)

5031

{

5032

if (s3_append_insn (append_str[i], FALSE) == (int) s3_FAIL)

5033

return;

5034

5035

memcpy (&inst_expand[i], &s3_inst, sizeof (struct s3_score_it));

5036

}

5037

5038

if (ldst_gp_p)

5039

{

5040

char *p;

5041

5042

/* Adjust instruction opcode and to be relaxed instruction opcode. */

5043

inst_main.instruction = s3_adjust_paritybit (inst_main.instruction, s3_GET_INSN_CLASS (inst_main.type));

5044

5045

/* relax lw rd, label -> ldis rs, imm16

5046

ori rd, imm16

5047

lw rd, [rs, imm15] or lw! rd, [rs, imm5]. */

5048

if (inst_expand[2].relax_size == 0)

5049

inst_main.relax_size = inst_expand[0].size + inst_expand[1].size + inst_expand[2].size;

5050

else

5051

inst_main.relax_size = inst_expand[0].size + inst_expand[1].size + inst_expand[2].relax_size;

5052

5053

inst_main.type = Insn_GP;

5054

5055

for (i = 0; i < 3; i++)

5056

inst_expand[i].instruction = s3_adjust_paritybit (inst_expand[i].instruction,

5057

s3_GET_INSN_CLASS (inst_expand[i].type));

5058

5059

/* Check data dependency. */

5060

s3_handle_dependency (&inst_main);

5061

5062

/* Start a new frag if frag_now is not empty. */

5063

if (frag_now_fix () != 0)

5064

{

5065

if (!frag_now->tc_frag_data.is_insn)

5066

frag_wane (frag_now);

5067

5068

frag_new (0);

5069

}

5070

frag_grow (20);

5071

5072

/* Write fr_fix part. */

5073

p = frag_more (inst_main.size);

5074

s3_md_number_to_chars (p, inst_main.instruction, inst_main.size);

5075

5076

if (inst_main.reloc.type != BFD_RELOC_NONE)

5077

{

5078

s3_fix_new_score (frag_now, p - frag_now->fr_literal, inst_main.size,

5079

&inst_main.reloc.exp, inst_main.reloc.pc_rel, inst_main.reloc.type);

5080

}

5081

5082

#ifdef OBJ_ELF

5083

dwarf2_emit_insn (inst_main.size);

5084

#endif

5085

5086

/* s3_GP instruction can not do optimization, only can do relax between

5087

1 instruction and 3 instructions. */

5088

p = frag_var (rs_machine_dependent, inst_main.relax_size + s3_RELAX_PAD_BYTE, 0,

5089

s3_RELAX_ENCODE (inst_main.size, inst_main.relax_size, inst_main.type, 0, 4, 0),

5090

inst_main.reloc.exp.X_add_symbol, 0, NULL);

5091

5092

/* Write fr_var part.

5093

no calling s3_gen_insn_frag, no fixS will be generated. */

5094

s3_md_number_to_chars (p, inst_expand[0].instruction, inst_expand[0].size);

5095

p += inst_expand[0].size;

5096

s3_md_number_to_chars (p, inst_expand[1].instruction, inst_expand[1].size);

5097

p += inst_expand[1].size;

5098

5099

/* relax lw rd, label -> ldis rs, imm16

5100

ori rd, imm16

5101

lw rd, [rs, imm15] or lw! rd, [rs, imm5]. */

5102

if (inst_expand[2].relax_size == 0)

5103

s3_md_number_to_chars (p, inst_expand[2].instruction, inst_expand[2].size);

5104

else

5105

s3_md_number_to_chars (p, inst_expand[2].relax_inst, inst_expand[2].relax_size);

5106

}

5107

else

5108

{

5109

s3_gen_insn_frag (&inst_expand[0], NULL);

5110

s3_gen_insn_frag (&inst_expand[1], NULL);

5111

s3_gen_insn_frag (&inst_expand[2], NULL);

5112

}

5113

s3_nor1 = r1_bak;

5114

5115

/* Set bwarn as -1, so macro instruction itself will not be generated frag. */

5116

s3_inst.bwarn = -1;

5117

}

5118

5119

static void

5120

s3_do_lw_pic (char *str)

5121

{

5122

int reg_rd;

5123

5124

s3_skip_whitespace (str);

5125

if (((reg_rd = s3_reg_required_here (&str, 20, s3_REG_TYPE_SCORE)) == (int) s3_FAIL)

5126

|| (s3_skip_past_comma (&str) == (int) s3_FAIL)

5127

|| (s3_my_get_expression (&s3_inst.reloc.exp, &str) == (int) s3_FAIL)

5128

|| (s3_end_of_line (str) == (int) s3_FAIL))

5129

{

5130

return;

5131

}

5132

else

5133

{

5134

if (s3_inst.reloc.exp.X_add_symbol == 0)

5135

{

5136

if (!s3_inst.error)

5137

s3_inst.error = s3_BAD_ARGS;

5138

5139

return;

5140

}

5141

5142

s3_inst.instruction |= s3_GP << 15;

5143

s3_inst.reloc.type = BFD_RELOC_SCORE_GOT15;

5144

}

5145

}

5146

5147

static void

5148

s3_do_empty (char *str)

5149

{

5150

str = str;

5151

if (s3_university_version == 1)

5152

{

5153

if (((s3_inst.instruction & 0x3e0003ff) == 0x0c000004)

5154

|| ((s3_inst.instruction & 0x3e0003ff) == 0x0c000024)

5155

|| ((s3_inst.instruction & 0x3e0003ff) == 0x0c000044)

5156

|| ((s3_inst.instruction & 0x3e0003ff) == 0x0c000064))

5157

{

5158

s3_inst.error = s3_ERR_FOR_SCORE5U_MMU;

5159

return;

5160

}

5161

}

5162

if (s3_end_of_line (str) == (int) s3_FAIL)

5163

return;

5164

5165

if (s3_inst.relax_inst != 0x8000)

5166

{

5167

if (s3_inst.type == NO_OPD)

5168

{

5169

s3_inst.relax_size = 2;

5170

}

5171

else

5172

{

5173

s3_inst.relax_size = 4;

5174

}

5175

}

5176

}

5177

5178

static void

5179

s3_do16_int (char *str)

5180

{

5181

s3_skip_whitespace (str);

5182

return;

5183

}

5184

5185

static void

5186

s3_do_jump (char *str)

5187

{

5188

char *save_in;

5189

5190

s3_skip_whitespace (str);

5191

if (s3_my_get_expression (&s3_inst.reloc.exp, &str) == (int) s3_FAIL

5192

|| s3_end_of_line (str) == (int) s3_FAIL)

5193

return;

5194

5195

if (s3_inst.reloc.exp.X_add_symbol == 0)

5196

{

5197

s3_inst.error = _("lacking label ");

5198

return;

5199

}

5200

5201

if (!(s3_inst.reloc.exp.X_add_number >= -16777216

5202

&& s3_inst.reloc.exp.X_add_number <= 16777215))

5203

{

5204

s3_inst.error = _("invalid constant: 25 bit expression not in range [-16777216, 16777215]");

5205

return;

5206

}

5207

5208

save_in = input_line_pointer;

5209

input_line_pointer = str;

5210

s3_inst.reloc.type = BFD_RELOC_SCORE_JMP;

5211

s3_inst.reloc.pc_rel = 1;

5212

input_line_pointer = save_in;

5213

}

5214

5215

static void

5216

s3_do_branch (char *str)

5217

{

5218

if (s3_my_get_expression (&s3_inst.reloc.exp, &str) == (int) s3_FAIL

5219

|| s3_end_of_line (str) == (int) s3_FAIL)

5220

{

5221

return;

5222

}

5223

else if (s3_inst.reloc.exp.X_add_symbol == 0)

5224

{

5225

s3_inst.error = _("lacking label ");

5226

return;

5227

}

5228

else if (!(s3_inst.reloc.exp.X_add_number >= -524288

5229

&& s3_inst.reloc.exp.X_add_number <= 524287))

5230

{

5231

s3_inst.error = _("invalid constant: 20 bit expression not in range -2^19..2^19");

5232

return;

5233

}

5234

5235

s3_inst.reloc.type = BFD_RELOC_SCORE_BRANCH;

5236

s3_inst.reloc.pc_rel = 1;

5237

5238

/* Branch 32 offset field : 20 bit, 16 bit branch offset field : 8 bit. */

5239

s3_inst.instruction |= (s3_inst.reloc.exp.X_add_number & 0x3fe) | ((s3_inst.reloc.exp.X_add_number & 0xffc00) << 5);

5240

5241

/* Compute 16 bit branch instruction. */

5242

if ((s3_inst.relax_inst != 0x8000)

5243

&& (s3_inst.reloc.exp.X_add_number >= -512 && s3_inst.reloc.exp.X_add_number <= 511))

5244

{

5245

s3_inst.relax_inst |= ((s3_inst.reloc.exp.X_add_number >> 1) & 0x1ff);/*b! :disp 9 bit */

5246

s3_inst.relax_size = 2;

5247

}

5248

else

5249

{

5250

s3_inst.relax_inst = 0x8000;

5251

}

5252

}

5253

5254

static void

5255

s3_do16_branch (char *str)

5256

{

5257

if ((s3_my_get_expression (&s3_inst.reloc.exp, &str) == (int) s3_FAIL

5258

|| s3_end_of_line (str) == (int) s3_FAIL))

5259

{

5260

;

5261

}

5262

else if (s3_inst.reloc.exp.X_add_symbol == 0)

5263

{

5264

s3_inst.error = _("lacking label");

5265

}

5266

else if (!(s3_inst.reloc.exp.X_add_number >= -512

5267

&& s3_inst.reloc.exp.X_add_number <= 511))

5268

{

5269

s3_inst.error = _("invalid constant: 10 bit expression not in range [-2^9, 2^9-1]");

5270

}

5271

else

5272

{

5273

s3_inst.reloc.type = BFD_RELOC_SCORE16_BRANCH;

5274

s3_inst.reloc.pc_rel = 1;

5275

s3_inst.instruction |= ((s3_inst.reloc.exp.X_add_number >> 1) & 0x1ff);

5276

s3_inst.relax_inst |= ((s3_inst.reloc.exp.X_add_number ) & 0x1ff);

5277

s3_inst.relax_size = 4;

5278

}

5279

}

5280

5281

/* Return true if the given symbol should be considered local for s3_PIC. */

5282

static bfd_boolean

5283

s3_pic_need_relax (symbolS *sym, asection *segtype)

5284

{

5285

asection *symsec;

5286

bfd_boolean linkonce;

5287

5288

/* Handle the case of a symbol equated to another symbol. */

5289

while (symbol_equated_reloc_p (sym))

5290

{

5291

symbolS *n;

5292

5293

/* It's possible to get a loop here in a badly written

5294

program. */

5295

n = symbol_get_value_expression (sym)->X_add_symbol;

5296

if (n == sym)

5297

break;

5298

sym = n;

5299

}

5300

5301

symsec = S_GET_SEGMENT (sym);

5302

5303

/* duplicate the test for LINK_ONCE sections as in adjust_reloc_syms */

5304

linkonce = FALSE;

5305

if (symsec != segtype && ! S_IS_LOCAL (sym))

5306

{

5307

if ((bfd_get_section_flags (stdoutput, symsec) & SEC_LINK_ONCE) != 0)

5308

linkonce = TRUE;

5309

5310

/* The GNU toolchain uses an extension for ELF: a section

5311

beginning with the magic string .gnu.linkonce is a linkonce

5312

section. */

5313

if (strncmp (segment_name (symsec), ".gnu.linkonce",

5314

sizeof ".gnu.linkonce" - 1) == 0)

5315

linkonce = TRUE;

5316

}

5317

5318

/* This must duplicate the test in adjust_reloc_syms. */

5319

return (!bfd_is_und_section (symsec)

5320

&& !bfd_is_abs_section (symsec)

5321

&& !bfd_is_com_section (symsec)

5322

&& !linkonce

5323

#ifdef OBJ_ELF

5324

/* A global or weak symbol is treated as external. */

5325

&& (OUTPUT_FLAVOR != bfd_target_elf_flavour

5326

|| (! S_IS_WEAK (sym) && ! S_IS_EXTERNAL (sym)))

5327

#endif

5328

);

5329

}

5330

5331

static void

5332

s3_parse_pce_inst (char *insnstr)

5333

{

5334

char c;

5335

char *p;

5336

char first[s3_MAX_LITERAL_POOL_SIZE];

5337

char second[s3_MAX_LITERAL_POOL_SIZE];

5338

struct s3_score_it pec_part_1;

5339

5340

/* Get first part string of PCE. */

5341

p = strstr (insnstr, "||");

5342

c = *p;

5343

*p = '\0';

5344

sprintf (first, "%s", insnstr);

5345

5346

/* Get second part string of PCE. */

5347

*p = c;

5348

p += 2;

5349

sprintf (second, "%s", p);

5350

5351

s3_parse_16_32_inst (first, FALSE);

5352

if (s3_inst.error)

5353

return;

5354

5355

memcpy (&pec_part_1, &s3_inst, sizeof (s3_inst));

5356

5357

s3_parse_16_32_inst (second, FALSE);

5358

if (s3_inst.error)

5359

return;

5360

5361

if ( ((pec_part_1.size == s3_INSN_SIZE) && (s3_inst.size == s3_INSN_SIZE))

5362

|| ((pec_part_1.size == s3_INSN_SIZE) && (s3_inst.size == s3_INSN16_SIZE))

5363

|| ((pec_part_1.size == s3_INSN16_SIZE) && (s3_inst.size == s3_INSN_SIZE)))

5364

{

5365

s3_inst.error = _("pce instruction error (16 bit || 16 bit)'");

5366

sprintf (s3_inst.str, insnstr);

5367

return;

5368

}

5369

5370

if (!s3_inst.error)

5371

s3_gen_insn_frag (&pec_part_1, &s3_inst);

5372

}

5373

5374

/* s3: dsp. */

5375

static void

5376

s3_do16_dsp (char *str)

5377

{

5378

int rd = 0;

5379

5380

/* Check 3d. */

5381

if (s3_score3d == 0)

5382

{

5383

s3_inst.error = _("score3d instruction.");

5384

return;

5385

}

5386

5387

s3_skip_whitespace (str);

5388

5389

if ((rd = s3_reglow_required_here (&str, 0)) == (int) s3_FAIL

5390

|| s3_end_of_line (str) == (int) s3_FAIL)

5391

{

5392

return;

5393

}

5394

else

5395

{

5396

s3_inst.relax_inst |= rd << 20;

5397

s3_inst.relax_size = 4;

5398

}

5399

}

5400

5401

static void

5402

s3_do16_dsp2 (char *str)

5403

{

5404

/* Check 3d. */

5405

if (s3_score3d == 0)

5406

{

5407

s3_inst.error = _("score3d instruction.");

5408

return;

5409

}

5410

5411

s3_skip_whitespace (str);

5412

5413

if (s3_reglow_required_here (&str, 4) == (int) s3_FAIL

5414

|| s3_skip_past_comma (&str) == (int) s3_FAIL

5415

|| s3_reglow_required_here (&str, 0) == (int) s3_FAIL

5416

|| s3_end_of_line (str) == (int) s3_FAIL)

5417

{

5418

return;

5419

}

5420

else

5421

{

5422

s3_inst.relax_inst |= (((s3_inst.instruction >> 8) & 0xf) << 20)

5423

| (((s3_inst.instruction >> 8) & 0xf) << 15) | (((s3_inst.instruction >> 4) & 0xf) << 10);

5424

s3_inst.relax_size = 4;

5425

}

5426

}

5427

5428

static void

5429

s3_do_dsp (char *str)

5430

{

5431

/* Check 3d. */

5432

if (s3_score3d == 0)

5433

{

5434

s3_inst.error = _("score3d instruction.");

5435

return;

5436

}

5437

5438

s3_skip_whitespace (str);

5439

5440

if (s3_reg_required_here (&str, 15, s3_REG_TYPE_SCORE) == (int) s3_FAIL

5441

|| s3_skip_past_comma (&str) == (int) s3_FAIL

5442

|| s3_reg_required_here (&str, 10, s3_REG_TYPE_SCORE) == (int) s3_FAIL

5443

|| s3_end_of_line (str) == (int) s3_FAIL)

5444

return;

5445

5446

if ((s3_inst.relax_inst != 0x8000) && (((s3_inst.instruction >> 20) & 0x1f) == 3) )

5447

{

5448

s3_inst.relax_inst |= (((s3_inst.instruction >> 10) & 0x1f)) | (((s3_inst.instruction >> 15) & 0x1f) << 5);

5449

s3_inst.relax_size = 2;

5450

}

5451

else

5452

s3_inst.relax_inst = 0x8000;

5453

}

5454

5455

static void

5456

s3_do_dsp2 (char *str)

5457

{

5458

int reg;

5459

5460

/* Check 3d. */

5461

if (s3_score3d == 0)

5462

{

5463

s3_inst.error = _("score3d instruction.");

5464

return;

5465

}

5466

5467

s3_skip_whitespace (str);

5468

5469

if ((reg = s3_reg_required_here (&str, 20, s3_REG_TYPE_SCORE)) == (int) s3_FAIL

5470

|| s3_skip_past_comma (&str) == (int) s3_FAIL

5471

|| s3_reg_required_here (&str, 15, s3_REG_TYPE_SCORE) == (int) s3_FAIL

5472

|| s3_skip_past_comma (&str) == (int) s3_FAIL

5473

|| s3_reg_required_here (&str, 10, s3_REG_TYPE_SCORE) == (int) s3_FAIL

5474

|| s3_end_of_line (str) == (int) s3_FAIL)

5475

{

5476

return;

5477

}

5478

else

5479

{

5480

/* Check mulr, mulur rd is even number. */

5481

if (((s3_inst.instruction & 0x3e0003ff) == 0x00000340

5482

|| (s3_inst.instruction & 0x3e0003ff) == 0x00000342)

5483

&& (reg % 2))

5484

{

5485

s3_inst.error = _("rd must be even number.");

5486

return;

5487

}

5488

5489

if ((((s3_inst.instruction >> 15) & 0x10) == 0)

5490

&& (((s3_inst.instruction >> 10) & 0x10) == 0)

5491

&& (((s3_inst.instruction >> 20) & 0x10) == 0)

5492

&& (s3_inst.relax_inst != 0x8000)

5493

&& (((s3_inst.instruction >> 20) & 0xf) == ((s3_inst.instruction >> 15) & 0xf)))

5494

{

5495

s3_inst.relax_inst |= (((s3_inst.instruction >> 10) & 0xf) )

5496

| (((s3_inst.instruction >> 15) & 0xf) << 4);

5497

s3_inst.relax_size = 2;

5498

}

5499

else

5500

{

5501

s3_inst.relax_inst = 0x8000;

5502

}

5503

}

5504

}

5505

5506

static void

5507

s3_do_dsp3 (char *str)

5508

{

5509

/* Check 3d. */

5510

if (s3_score3d == 0)

5511

{

5512

s3_inst.error = _("score3d instruction.");

5513

return;

5514

}

5515

5516

s3_skip_whitespace (str);

5517

5518

if (s3_reg_required_here (&str, 20, s3_REG_TYPE_SCORE) == (int) s3_FAIL

5519

|| s3_skip_past_comma (&str) == (int) s3_FAIL

5520

|| s3_reg_required_here (&str, 15, s3_REG_TYPE_SCORE) == (int) s3_FAIL

5521

|| s3_end_of_line (str) == (int) s3_FAIL)

5522

return;

5523

5524

if ((s3_inst.relax_inst != 0x8000) && (((s3_inst.instruction >> 20) & 0x1f) == 3) )

5525

{

5526

s3_inst.relax_inst |= (((s3_inst.instruction >> 10) & 0x1f)) | (((s3_inst.instruction >> 15) & 0x1f) << 5);

5527

s3_inst.relax_size = 2;

5528

}

5529

else

5530

s3_inst.relax_inst = 0x8000;

5531

}

5532

5533

5534

/* If we change section we must dump the literal pool first. */

5535

static void

5536

s3_s_score_bss (int ignore ATTRIBUTE_UNUSED)

5537

{

5538

subseg_set (bss_section, (subsegT) get_absolute_expression ());

5539

demand_empty_rest_of_line ();

5540

}

5541

5542

static void

5543

s3_s_score_text (int ignore)

5544

{

5545

obj_elf_text (ignore);

5546

record_alignment (now_seg, 2);

5547

}

5548

5549

static void

5550

s3_score_s_section (int ignore)

5551

{

5552

obj_elf_section (ignore);

5553

if ((bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE) != 0)

5554

record_alignment (now_seg, 2);

5555

5556

}

5557

5558

static void

5559

s3_s_change_sec (int sec)

5560

{

5561

segT seg;

5562

5563

#ifdef OBJ_ELF

5564

/* The ELF backend needs to know that we are changing sections, so

5565

that .previous works correctly. We could do something like check

5566

for an obj_section_change_hook macro, but that might be confusing

5567

as it would not be appropriate to use it in the section changing

5568

functions in read.c, since obj-elf.c intercepts those. FIXME:

5569

This should be cleaner, somehow. */

5570

obj_elf_section_change_hook ();

5571

#endif

5572

switch (sec)

5573

{

5574

case 'r':

5575

seg = subseg_new (s3_RDATA_SECTION_NAME, (subsegT) get_absolute_expression ());

5576

bfd_set_section_flags (stdoutput, seg, (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_RELOC | SEC_DATA));

5577

if (strcmp (TARGET_OS, "elf") != 0)

5578

record_alignment (seg, 4);

5579

demand_empty_rest_of_line ();

5580

break;

5581

case 's':

5582

seg = subseg_new (".sdata", (subsegT) get_absolute_expression ());

5583

bfd_set_section_flags (stdoutput, seg, SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_DATA);

5584

if (strcmp (TARGET_OS, "elf") != 0)

5585

record_alignment (seg, 4);

5586

demand_empty_rest_of_line ();

5587

break;

5588

}

5589

}

5590

5591

static void

5592

s3_s_score_mask (int reg_type ATTRIBUTE_UNUSED)

5593

{

5594

long mask, off;

5595

5596

if (s3_cur_proc_ptr == (s3_procS *) NULL)

5597

{

5598

as_warn (_(".mask outside of .ent"));

5599

demand_empty_rest_of_line ();

5600

return;

5601

}

5602

if (get_absolute_expression_and_terminator (&mask) != ',')

5603

{

5604

as_warn (_("Bad .mask directive"));

5605

--input_line_pointer;

5606

demand_empty_rest_of_line ();

5607

return;

5608

}

5609

off = get_absolute_expression ();

5610

s3_cur_proc_ptr->reg_mask = mask;

5611

s3_cur_proc_ptr->reg_offset = off;

5612

demand_empty_rest_of_line ();

5613

}

5614

5615

static symbolS *

5616

s3_get_symbol (void)

5617

{

5618

int c;

5619

char *name;

5620

symbolS *p;

5621

5622

name = input_line_pointer;

5623

c = get_symbol_end ();

5624

p = (symbolS *) symbol_find_or_make (name);

5625

*input_line_pointer = c;

5626

return p;

5627

}

5628

5629

static long

5630

s3_get_number (void)

5631

{

5632

int negative = 0;

5633

long val = 0;

5634

5635

if (*input_line_pointer == '-')

5636

{

5637

++input_line_pointer;

5638

negative = 1;

5639

}

5640

if (!ISDIGIT (*input_line_pointer))

5641

as_bad (_("expected simple number"));

5642

if (input_line_pointer[0] == '0')

5643

{

5644

if (input_line_pointer[1] == 'x')

5645

{

5646

input_line_pointer += 2;

5647

while (ISXDIGIT (*input_line_pointer))

5648

{

5649

val <<= 4;

5650

val |= hex_value (*input_line_pointer++);

5651

}

5652

return negative ? -val : val;

5653

}

5654

else

5655

{

5656

++input_line_pointer;

5657

while (ISDIGIT (*input_line_pointer))

5658

{

5659

val <<= 3;

5660

val |= *input_line_pointer++ - '0';

5661

}

5662

return negative ? -val : val;

5663

}

5664

}

5665

if (!ISDIGIT (*input_line_pointer))

5666

{

5667

printf (_(" *input_line_pointer == '%c' 0x%02x\n"), *input_line_pointer, *input_line_pointer);

5668

as_warn (_("invalid number"));

5669

return -1;

5670

}

5671

while (ISDIGIT (*input_line_pointer))

5672

{

5673

val *= 10;

5674

val += *input_line_pointer++ - '0';

5675

}

5676

return negative ? -val : val;

5677

}

5678

5679

/* The .aent and .ent directives. */

5680

static void

5681

s3_s_score_ent (int aent)

5682

{

5683

symbolS *symbolP;

5684

int maybe_text;

5685

5686

symbolP = s3_get_symbol ();

5687

if (*input_line_pointer == ',')

5688

++input_line_pointer;

5689

SKIP_WHITESPACE ();

5690

if (ISDIGIT (*input_line_pointer) || *input_line_pointer == '-')

5691

s3_get_number ();

5692

5693

#ifdef BFD_ASSEMBLER

5694

if ((bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE) != 0)

5695

maybe_text = 1;

5696

else

5697

maybe_text = 0;

5698

#else

5699

if (now_seg != data_section && now_seg != bss_section)

5700

maybe_text = 1;

5701

else

5702

maybe_text = 0;

5703

#endif

5704

if (!maybe_text)

5705

as_warn (_(".ent or .aent not in text section."));

5706

if (!aent && s3_cur_proc_ptr)

5707

as_warn (_("missing .end"));

5708

if (!aent)

5709

{

5710

s3_cur_proc_ptr = &s3_cur_proc;

5711

s3_cur_proc_ptr->reg_mask = 0xdeadbeaf;

5712

s3_cur_proc_ptr->reg_offset = 0xdeadbeaf;

5713

s3_cur_proc_ptr->fpreg_mask = 0xdeafbeaf;

5714

s3_cur_proc_ptr->leaf = 0xdeafbeaf;

5715

s3_cur_proc_ptr->frame_offset = 0xdeafbeaf;

5716

s3_cur_proc_ptr->frame_reg = 0xdeafbeaf;

5717

s3_cur_proc_ptr->pc_reg = 0xdeafbeaf;

5718

s3_cur_proc_ptr->isym = symbolP;

5719

symbol_get_bfdsym (symbolP)->flags |= BSF_FUNCTION;

5720

++s3_numprocs;

5721

if (debug_type == DEBUG_STABS)

5722

stabs_generate_asm_func (S_GET_NAME (symbolP), S_GET_NAME (symbolP));

5723

}

5724

demand_empty_rest_of_line ();

5725

}

5726

5727

static void

5728

s3_s_score_frame (int ignore ATTRIBUTE_UNUSED)

5729

{

5730

char *backupstr;

5731

char str[30];

5732

long val;

5733

int i = 0;

5734

5735

backupstr = input_line_pointer;

5736

5737

#ifdef OBJ_ELF

5738

if (s3_cur_proc_ptr == (s3_procS *) NULL)

5739

{

5740

as_warn (_(".frame outside of .ent"));

5741

demand_empty_rest_of_line ();

5742

return;

5743

}

5744

s3_cur_proc_ptr->frame_reg = s3_reg_required_here ((&backupstr), 0, s3_REG_TYPE_SCORE);

5745

SKIP_WHITESPACE ();

5746

s3_skip_past_comma (&backupstr);

5747

while (*backupstr != ',')

5748

{

5749

str[i] = *backupstr;

5750

i++;

5751

backupstr++;

5752

}

5753

str[i] = '\0';

5754

val = atoi (str);

5755

5756

SKIP_WHITESPACE ();

5757

s3_skip_past_comma (&backupstr);

5758

s3_cur_proc_ptr->frame_offset = val;

5759

s3_cur_proc_ptr->pc_reg = s3_reg_required_here ((&backupstr), 0, s3_REG_TYPE_SCORE);

5760

5761

SKIP_WHITESPACE ();

5762

s3_skip_past_comma (&backupstr);

5763

i = 0;

5764

while (*backupstr != '\n')

5765

{

5766

str[i] = *backupstr;

5767

i++;

5768

backupstr++;

5769

}

5770

str[i] = '\0';

5771

val = atoi (str);

5772

s3_cur_proc_ptr->leaf = val;

5773

SKIP_WHITESPACE ();

5774

s3_skip_past_comma (&backupstr);

5775

5776

#endif /* OBJ_ELF */

5777

while (input_line_pointer != backupstr)

5778

input_line_pointer++;

5779

}

5780

5781

/* The .end directive. */

5782

static void

5783

s3_s_score_end (int x ATTRIBUTE_UNUSED)

5784

{

5785

symbolS *p;

5786

int maybe_text;

5787

5788

/* Generate a .pdr section. */

5789

segT saved_seg = now_seg;

5790

subsegT saved_subseg = now_subseg;

5791

expressionS exp;

5792

char *fragp;

5793

5794

if (!is_end_of_line[(unsigned char)*input_line_pointer])

5795

{

5796

p = s3_get_symbol ();

5797

demand_empty_rest_of_line ();

5798

}

5799

else

5800

p = NULL;

5801

5802

#ifdef BFD_ASSEMBLER

5803

if ((bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE) != 0)

5804

maybe_text = 1;

5805

else

5806

maybe_text = 0;

5807

#else

5808

if (now_seg != data_section && now_seg != bss_section)

5809

maybe_text = 1;

5810

else

5811

maybe_text = 0;

5812

#endif

5813

5814

if (!maybe_text)

5815

as_warn (_(".end not in text section"));

5816

if (!s3_cur_proc_ptr)

5817

{

5818

as_warn (_(".end directive without a preceding .ent directive."));

5819

demand_empty_rest_of_line ();

5820

return;

5821

}

5822

if (p != NULL)

5823

{

5824

gas_assert (S_GET_NAME (p));

5825

if (strcmp (S_GET_NAME (p), S_GET_NAME (s3_cur_proc_ptr->isym)))

5826

as_warn (_(".end symbol does not match .ent symbol."));

5827

if (debug_type == DEBUG_STABS)

5828

stabs_generate_asm_endfunc (S_GET_NAME (p), S_GET_NAME (p));

5829

}

5830

else

5831

as_warn (_(".end directive missing or unknown symbol"));

5832

5833

if ((s3_cur_proc_ptr->reg_mask == 0xdeadbeaf) ||

5834

(s3_cur_proc_ptr->reg_offset == 0xdeadbeaf) ||

5835

(s3_cur_proc_ptr->leaf == 0xdeafbeaf) ||

5836

(s3_cur_proc_ptr->frame_offset == 0xdeafbeaf) ||

5837

(s3_cur_proc_ptr->frame_reg == 0xdeafbeaf) || (s3_cur_proc_ptr->pc_reg == 0xdeafbeaf));

5838

5839

else

5840

{

5841

(void) frag_now_fix ();

5842

gas_assert (s3_pdr_seg);

5843

subseg_set (s3_pdr_seg, 0);

5844

/* Write the symbol. */

5845

exp.X_op = O_symbol;

5846

exp.X_add_symbol = p;

5847

exp.X_add_number = 0;

5848

emit_expr (&exp, 4);

5849

fragp = frag_more (7 * 4);

5850

md_number_to_chars (fragp, (valueT) s3_cur_proc_ptr->reg_mask, 4);

5851

md_number_to_chars (fragp + 4, (valueT) s3_cur_proc_ptr->reg_offset, 4);

5852

md_number_to_chars (fragp + 8, (valueT) s3_cur_proc_ptr->fpreg_mask, 4);

5853

md_number_to_chars (fragp + 12, (valueT) s3_cur_proc_ptr->leaf, 4);

5854

md_number_to_chars (fragp + 16, (valueT) s3_cur_proc_ptr->frame_offset, 4);

5855

md_number_to_chars (fragp + 20, (valueT) s3_cur_proc_ptr->frame_reg, 4);

5856

md_number_to_chars (fragp + 24, (valueT) s3_cur_proc_ptr->pc_reg, 4);

5857

subseg_set (saved_seg, saved_subseg);

5858

5859

}

5860

s3_cur_proc_ptr = NULL;

5861

}

5862

5863

/* Handle the .set pseudo-op. */

5864

static void

5865

s3_s_score_set (int x ATTRIBUTE_UNUSED)

5866

{

5867

int i = 0;

5868

char name[s3_MAX_LITERAL_POOL_SIZE];

5869

char * orig_ilp = input_line_pointer;

5870

5871

while (!is_end_of_line[(unsigned char)*input_line_pointer])

5872

{

5873

name[i] = (char) * input_line_pointer;

5874

i++;

5875

++input_line_pointer;

5876

}

5877

5878

name[i] = '\0';

5879

5880

if (strcmp (name, "nwarn") == 0)

5881

{

5882

s3_warn_fix_data_dependency = 0;

5883

}

5884

else if (strcmp (name, "fixdd") == 0)

5885

{

5886

s3_fix_data_dependency = 1;

5887

}

5888

else if (strcmp (name, "nofixdd") == 0)

5889

{

5890

s3_fix_data_dependency = 0;

5891

}

5892

else if (strcmp (name, "r1") == 0)

5893

{

5894

s3_nor1 = 0;

5895

}

5896

else if (strcmp (name, "nor1") == 0)

5897

{

5898

s3_nor1 = 1;

5899

}

5900

else if (strcmp (name, "optimize") == 0)

5901

{

5902

s3_g_opt = 1;

5903

}

5904

else if (strcmp (name, "volatile") == 0)

5905

{

5906

s3_g_opt = 0;

5907

}

5908

else if (strcmp (name, "pic") == 0)

5909

{

5910

s3_score_pic = s3_PIC;

5911

}

5912

else

5913

{

5914

input_line_pointer = orig_ilp;

5915

s_set (0);

5916

}

5917

}

5918

5919

/* Handle the .cpload pseudo-op. This is used when generating s3_PIC code. It sets the

5920

$gp register for the function based on the function address, which is in the register

5921

named in the argument. This uses a relocation against GP_DISP_LABEL, which is handled

5922

specially by the linker. The result is:

5923

ldis gp, %hi(GP_DISP_LABEL)

5924

ori gp, %low(GP_DISP_LABEL)

5925

add gp, gp, .cpload argument

5926

The .cpload argument is normally r29. */

5927

static void

5928

s3_s_score_cpload (int ignore ATTRIBUTE_UNUSED)

5929

{

5930

int reg;

5931

char insn_str[s3_MAX_LITERAL_POOL_SIZE];

5932

5933

/* If we are not generating s3_PIC code, .cpload is ignored. */

5934

if (s3_score_pic == s3_NO_PIC)

5935

{

5936

s_ignore (0);

5937

return;

5938

}

5939

5940

if ((reg = s3_reg_required_here (&input_line_pointer, -1, s3_REG_TYPE_SCORE)) == (int) s3_FAIL)

5941

return;

5942

5943

demand_empty_rest_of_line ();

5944

5945

sprintf (insn_str, "ld_i32hi r%d, %s", s3_GP, GP_DISP_LABEL);

5946

if (s3_append_insn (insn_str, TRUE) == (int) s3_FAIL)

5947

return;

5948

5949

sprintf (insn_str, "ld_i32lo r%d, %s", s3_GP, GP_DISP_LABEL);

5950

if (s3_append_insn (insn_str, TRUE) == (int) s3_FAIL)

5951

return;

5952

5953

sprintf (insn_str, "add r%d, r%d, r%d", s3_GP, s3_GP, reg);

5954

if (s3_append_insn (insn_str, TRUE) == (int) s3_FAIL)

5955

return;

5956

}

5957

5958

/* Handle the .cprestore pseudo-op. This stores $gp into a given

5959

offset from $sp. The offset is remembered, and after making a s3_PIC

5960

call $gp is restored from that location. */

5961

static void

5962

s3_s_score_cprestore (int ignore ATTRIBUTE_UNUSED)

5963

{

5964

int reg;

5965

int cprestore_offset;

5966

char insn_str[s3_MAX_LITERAL_POOL_SIZE];

5967

5968

/* If we are not generating s3_PIC code, .cprestore is ignored. */

5969

if (s3_score_pic == s3_NO_PIC)

5970

{

5971

s_ignore (0);

5972

return;

5973

}

5974

5975

if ((reg = s3_reg_required_here (&input_line_pointer, -1, s3_REG_TYPE_SCORE)) == (int) s3_FAIL

5976

|| s3_skip_past_comma (&input_line_pointer) == (int) s3_FAIL)

5977

{

5978

return;

5979

}

5980

5981

cprestore_offset = get_absolute_expression ();

5982

5983

if (cprestore_offset <= 0x3fff)

5984

{

5985

sprintf (insn_str, "sw r%d, [r%d, %d]", s3_GP, reg, cprestore_offset);

5986

if (s3_append_insn (insn_str, TRUE) == (int) s3_FAIL)

5987

return;

5988

}

5989

else

5990

{

5991

int r1_bak;

5992

5993

r1_bak = s3_nor1;

5994

s3_nor1 = 0;

5995

5996

sprintf (insn_str, "li r1, %d", cprestore_offset);

5997

if (s3_append_insn (insn_str, TRUE) == (int) s3_FAIL)

5998

return;

5999

6000

sprintf (insn_str, "add r1, r1, r%d", reg);

6001

if (s3_append_insn (insn_str, TRUE) == (int) s3_FAIL)

6002

return;

6003

6004

sprintf (insn_str, "sw r%d, [r1]", s3_GP);

6005

if (s3_append_insn (insn_str, TRUE) == (int) s3_FAIL)

6006

return;

6007

6008

s3_nor1 = r1_bak;

6009

}

6010

6011

demand_empty_rest_of_line ();

6012

}

6013

6014

/* Handle the .gpword pseudo-op. This is used when generating s3_PIC

6015

code. It generates a 32 bit s3_GP relative reloc. */

6016

static void

6017

s3_s_score_gpword (int ignore ATTRIBUTE_UNUSED)

6018

{

6019

expressionS ex;

6020

char *p;

6021

6022

/* When not generating s3_PIC code, this is treated as .word. */

6023

if (s3_score_pic == s3_NO_PIC)

6024

{

6025

cons (4);

6026

return;

6027

}

6028

expression (&ex);

6029

if (ex.X_op != O_symbol || ex.X_add_number != 0)

6030

{

6031

as_bad (_("Unsupported use of .gpword"));

6032

ignore_rest_of_line ();

6033

}

6034

p = frag_more (4);

6035

s3_md_number_to_chars (p, (valueT) 0, 4);

6036

fix_new_exp (frag_now, p - frag_now->fr_literal, 4, &ex, FALSE, BFD_RELOC_GPREL32);

6037

demand_empty_rest_of_line ();

6038

}

6039

6040

/* Handle the .cpadd pseudo-op. This is used when dealing with switch

6041

tables in s3_PIC code. */

6042

static void

6043

s3_s_score_cpadd (int ignore ATTRIBUTE_UNUSED)

6044

{

6045

int reg;

6046

char insn_str[s3_MAX_LITERAL_POOL_SIZE];

6047

6048

/* If we are not generating s3_PIC code, .cpload is ignored. */

6049

if (s3_score_pic == s3_NO_PIC)

6050

{

6051

s_ignore (0);

6052

return;

6053

}

6054

6055

if ((reg = s3_reg_required_here (&input_line_pointer, -1, s3_REG_TYPE_SCORE)) == (int) s3_FAIL)

6056

{

6057

return;

6058

}

6059

demand_empty_rest_of_line ();

6060

6061

/* Add $gp to the register named as an argument. */

6062

sprintf (insn_str, "add r%d, r%d, r%d", reg, reg, s3_GP);

6063

if (s3_append_insn (insn_str, TRUE) == (int) s3_FAIL)

6064

return;

6065

}

6066

6067

#ifndef TC_IMPLICIT_LCOMM_ALIGNMENT

6068

#define TC_IMPLICIT_LCOMM_ALIGNMENT(SIZE, P2VAR) \

6069

do \

6070

{ \

6071

if ((SIZE) >= 8) \

6072

(P2VAR) = 3; \

6073

else if ((SIZE) >= 4) \

6074

(P2VAR) = 2; \

6075

else if ((SIZE) >= 2) \

6076

(P2VAR) = 1; \

6077

else \

6078

(P2VAR) = 0; \

6079

} \

6080

while (0)

6081

#endif

6082

6083

static void

6084

s3_s_score_lcomm (int bytes_p)

6085

{

6086

char *name;

6087

char c;

6088

char *p;

6089

int temp;

6090

symbolS *symbolP;

6091

segT current_seg = now_seg;

6092

subsegT current_subseg = now_subseg;

6093

const int max_alignment = 15;

6094

int align = 0;

6095

segT bss_seg = bss_section;

6096

int needs_align = 0;

6097

6098

name = input_line_pointer;

6099

c = get_symbol_end ();

6100

p = input_line_pointer;

6101

*p = c;

6102

6103

if (name == p)

6104

{

6105

as_bad (_("expected symbol name"));

6106

discard_rest_of_line ();

6107

return;

6108

}

6109

6110

SKIP_WHITESPACE ();

6111

6112

/* Accept an optional comma after the name. The comma used to be

6113

required, but Irix 5 cc does not generate it. */

6114

if (*input_line_pointer == ',')

6115

{

6116

++input_line_pointer;

6117

SKIP_WHITESPACE ();

6118

}

6119

6120

if (is_end_of_line[(unsigned char)*input_line_pointer])

6121

{

6122

as_bad (_("missing size expression"));

6123

return;

6124

}

6125

6126

if ((temp = get_absolute_expression ()) < 0)

6127

{

6128

as_warn (_("BSS length (%d) < 0 ignored"), temp);

6129

ignore_rest_of_line ();

6130

return;

6131

}

6132

6133

#if defined (TC_SCORE)

6134

if (OUTPUT_FLAVOR == bfd_target_ecoff_flavour || OUTPUT_FLAVOR == bfd_target_elf_flavour)

6135

{

6136

/* For Score and Alpha ECOFF or ELF, small objects are put in .sbss. */

6137

if ((unsigned)temp <= bfd_get_gp_size (stdoutput))

6138

{

6139

bss_seg = subseg_new (".sbss", 1);

6140

seg_info (bss_seg)->bss = 1;

6141

#ifdef BFD_ASSEMBLER

6142

if (!bfd_set_section_flags (stdoutput, bss_seg, SEC_ALLOC))

6143

as_warn (_("error setting flags for \".sbss\": %s"), bfd_errmsg (bfd_get_error ()));

6144

#endif

6145

}

6146

}

6147

#endif

6148

6149

SKIP_WHITESPACE ();

6150

if (*input_line_pointer == ',')

6151

{

6152

++input_line_pointer;

6153

SKIP_WHITESPACE ();

6154

6155

if (is_end_of_line[(unsigned char)*input_line_pointer])

6156

{

6157

as_bad (_("missing alignment"));

6158

return;

6159

}

6160

else

6161

{

6162

align = get_absolute_expression ();

6163

needs_align = 1;

6164

}

6165

}

6166

6167

if (!needs_align)

6168

{

6169

TC_IMPLICIT_LCOMM_ALIGNMENT (temp, align);

6170

6171

/* Still zero unless TC_IMPLICIT_LCOMM_ALIGNMENT set it. */

6172

if (align)

6173

record_alignment (bss_seg, align);

6174

}

6175

6176

if (needs_align)

6177

{

6178

if (bytes_p)

6179

{

6180

/* Convert to a power of 2. */

6181

if (align != 0)

6182

{

6183

unsigned int i;

6184

6185

for (i = 0; align != 0; align >>= 1, ++i)

6186

;

6187

align = i - 1;

6188

}

6189

}

6190

6191

if (align > max_alignment)

6192

{

6193

align = max_alignment;

6194

as_warn (_("alignment too large; %d assumed"), align);

6195

}

6196

else if (align < 0)

6197

{

6198

align = 0;

6199

as_warn (_("alignment negative; 0 assumed"));

6200

}

6201

6202

record_alignment (bss_seg, align);

6203

}

6204

else

6205

{

6206

/* Assume some objects may require alignment on some systems. */

6207

#if defined (TC_ALPHA) && ! defined (VMS)

6208

if (temp > 1)

6209

{

6210

align = ffs (temp) - 1;

6211

if (temp % (1 << align))

6212

abort ();

6213

}

6214

#endif

6215

}

6216

6217

*p = 0;

6218

symbolP = symbol_find_or_make (name);

6219

*p = c;

6220

6221

if (

6222

#if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT) \

6223

|| defined (OBJ_BOUT) || defined (OBJ_MAYBE_BOUT))

6224

#ifdef BFD_ASSEMBLER

6225

(OUTPUT_FLAVOR != bfd_target_aout_flavour

6226

|| (S_GET_OTHER (symbolP) == 0 && S_GET_DESC (symbolP) == 0)) &&

6227

#else

6228

(S_GET_OTHER (symbolP) == 0 && S_GET_DESC (symbolP) == 0) &&

6229

#endif

6230

#endif

6231

(S_GET_SEGMENT (symbolP) == bss_seg || (!S_IS_DEFINED (symbolP) && S_GET_VALUE (symbolP) == 0)))

6232

{

6233

char *pfrag;

6234

6235

subseg_set (bss_seg, 1);

6236

6237

if (align)

6238

frag_align (align, 0, 0);

6239

6240

/* Detach from old frag. */

6241

if (S_GET_SEGMENT (symbolP) == bss_seg)

6242

symbol_get_frag (symbolP)->fr_symbol = NULL;

6243

6244

symbol_set_frag (symbolP, frag_now);

6245

pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP, (offsetT) temp, NULL);

6246

*pfrag = 0;

6247

6248

6249

S_SET_SEGMENT (symbolP, bss_seg);

6250

6251

#ifdef OBJ_COFF

6252

/* The symbol may already have been created with a preceding

6253

".globl" directive -- be careful not to step on storage class

6254

in that case. Otherwise, set it to static. */

6255

if (S_GET_STORAGE_CLASS (symbolP) != C_EXT)

6256

{

6257

S_SET_STORAGE_CLASS (symbolP, C_STAT);

6258

}

6259

#endif /* OBJ_COFF */

6260

6261

#ifdef S_SET_SIZE

6262

S_SET_SIZE (symbolP, temp);

6263

#endif

6264

}

6265

else

6266

as_bad (_("symbol `%s' is already defined"), S_GET_NAME (symbolP));

6267

6268

subseg_set (current_seg, current_subseg);

6269

6270

demand_empty_rest_of_line ();

6271

}

6272

6273

static void

6274

s3_insert_reg (const struct s3_reg_entry *r, struct hash_control *htab)

6275

{

6276

int i = 0;

6277

int len = strlen (r->name) + 2;

6278

char *buf = xmalloc (len);

6279

char *buf2 = xmalloc (len);

6280

6281

strcpy (buf + i, r->name);

6282

for (i = 0; buf[i]; i++)

6283

{

6284

buf2[i] = TOUPPER (buf[i]);

6285

}

6286

buf2[i] = '\0';

6287

6288

hash_insert (htab, buf, (void *) r);

6289

hash_insert (htab, buf2, (void *) r);

6290

}

6291

6292

static void

6293

s3_build_reg_hsh (struct s3_reg_map *map)

6294

{

6295

const struct s3_reg_entry *r;

6296

6297

if ((map->htab = hash_new ()) == NULL)

6298

{

6299

as_fatal (_("virtual memory exhausted"));

6300

}

6301

for (r = map->names; r->name != NULL; r++)

6302

{

6303

s3_insert_reg (r, map->htab);

6304

}

6305

}

6306

6307

/* Iterate over the base tables to create the instruction patterns. */

6308

static void

6309

s3_build_score_ops_hsh (void)

6310

{

6311

unsigned int i;

6312

static struct obstack insn_obstack;

6313

6314

obstack_begin (&insn_obstack, 4000);

6315

for (i = 0; i < sizeof (s3_score_insns) / sizeof (struct s3_asm_opcode); i++)

6316

{

6317

const struct s3_asm_opcode *insn = s3_score_insns + i;

6318

unsigned len = strlen (insn->template_name);

6319

struct s3_asm_opcode *new_opcode;

6320

char *template_name;

6321

new_opcode = (struct s3_asm_opcode *)

6322

obstack_alloc (&insn_obstack, sizeof (struct s3_asm_opcode));

6323

template_name = (char *) obstack_alloc (& insn_obstack, len + 1);

6324

6325

strcpy (template_name, insn->template_name);

6326

new_opcode->template_name = template_name;

6327

new_opcode->parms = insn->parms;

6328

new_opcode->value = insn->value;

6329

new_opcode->relax_value = insn->relax_value;

6330

new_opcode->type = insn->type;

6331

new_opcode->bitmask = insn->bitmask;

6332

hash_insert (s3_score_ops_hsh, new_opcode->template_name,

6333

(void *) new_opcode);

6334

}

6335

}

6336

6337

static void

6338

s3_build_dependency_insn_hsh (void)

6339

{

6340

unsigned int i;

6341

static struct obstack dependency_obstack;

6342

6343

obstack_begin (&dependency_obstack, 4000);

6344

for (i = 0; i < sizeof (s3_insn_to_dependency_table) / sizeof (s3_insn_to_dependency_table[0]); i++)

6345

{

6346

const struct s3_insn_to_dependency *tmp = s3_insn_to_dependency_table + i;

6347

unsigned len = strlen (tmp->insn_name);

6348

struct s3_insn_to_dependency *new_i2n;

6349

6350

new_i2n = (struct s3_insn_to_dependency *)

6351

obstack_alloc (&dependency_obstack,

6352

sizeof (struct s3_insn_to_dependency));

6353

new_i2n->insn_name = (char *) obstack_alloc (&dependency_obstack,

6354

len + 1);

6355

6356

strcpy (new_i2n->insn_name, tmp->insn_name);

6357

new_i2n->type = tmp->type;

6358

hash_insert (s3_dependency_insn_hsh, new_i2n->insn_name,

6359

(void *) new_i2n);

6360

}

6361

}

6362

6363

static void

6364

s_score_bss (int ignore ATTRIBUTE_UNUSED)

6365

{

6366

if (score3)

6367

return s3_s_score_bss (ignore);

6368

else

6369

return s7_s_score_bss (ignore);

6370

}

6371

6372

static void

6373

s_score_text (int ignore)

6374

{

6375

if (score3)

6376

return s3_s_score_text (ignore);

6377

else

6378

return s7_s_score_text (ignore);

6379

}

6380

6381

static void

6382

s_section (int ignore)

6383

{

6384

if (score3)

6385

return s3_score_s_section (ignore);

6386

else

6387

return s7_s_section (ignore);

6388

}

6389

6390

static void

6391

s_change_sec (int sec)

6392

{

6393

if (score3)

6394

return s3_s_change_sec (sec);

6395

else

6396

return s7_s_change_sec (sec);

6397

}

6398

6399

static void

6400

s_score_mask (int reg_type ATTRIBUTE_UNUSED)

6401

{

6402

if (score3)

6403

return s3_s_score_mask (reg_type);

6404

else

6405

return s7_s_score_mask (reg_type);

6406

}

6407

6408

static void

6409

s_score_ent (int aent)

6410

{

6411

if (score3)

6412

return s3_s_score_ent (aent);

6413

else

6414

return s7_s_score_ent (aent);

6415

}

6416

6417

static void

6418

s_score_frame (int ignore ATTRIBUTE_UNUSED)

6419

{

6420

if (score3)

6421

return s3_s_score_frame (ignore);

6422

else

6423

return s7_s_score_frame (ignore);

6424

}

6425

6426

static void

6427

s_score_end (int x ATTRIBUTE_UNUSED)

6428

{

6429

if (score3)

6430

return s3_s_score_end (x);

6431

else

6432

return s7_s_score_end (x);

6433

}

6434

6435

static void

6436

s_score_set (int x ATTRIBUTE_UNUSED)

6437

{

6438

if (score3)

6439

return s3_s_score_set (x);

6440

else

6441

return s7_s_score_set (x);

6442

}

6443

6444

static void

6445

s_score_cpload (int ignore ATTRIBUTE_UNUSED)

6446

{

6447

if (score3)

6448

return s3_s_score_cpload (ignore);

6449

else

6450

return s7_s_score_cpload (ignore);

6451

}

6452

6453

static void

6454

s_score_cprestore (int ignore ATTRIBUTE_UNUSED)

6455

{

6456

if (score3)

6457

return s3_s_score_cprestore (ignore);

6458

else

6459

return s7_s_score_cprestore (ignore);

6460

}

6461

6462

static void

6463

s_score_gpword (int ignore ATTRIBUTE_UNUSED)

6464

{

6465

if (score3)

6466

return s3_s_score_gpword (ignore);

6467

else

6468

return s7_s_score_gpword (ignore);

6469

}

6470

6471

static void

6472

s_score_cpadd (int ignore ATTRIBUTE_UNUSED)

6473

{

6474

if (score3)

6475

return s3_s_score_cpadd (ignore);

6476

else

6477

return s7_s_score_cpadd (ignore);

6478

}

6479

6480

static void

6481

s_score_lcomm (int bytes_p)

6482

{

6483

if (score3)

6484

return s3_s_score_lcomm (bytes_p);

6485

else

6486

return s7_s_score_lcomm (bytes_p);

6487

}

6488

6489

static void

6490

s3_assemble (char *str)

6491

{

6492

know (str);

6493

know (strlen (str) < s3_MAX_LITERAL_POOL_SIZE);

6494

6495

memset (&s3_inst, '\0', sizeof (s3_inst));

6496

if (s3_INSN_IS_PCE_P (str))

6497

s3_parse_pce_inst (str);

6498

else if (s3_INSN_IS_48_P (str))

6499

s3_parse_48_inst (str, TRUE);

6500

else

6501

s3_parse_16_32_inst (str, TRUE);

6502

6503

if (s3_inst.error)

6504

as_bad (_("%s -- `%s'"), s3_inst.error, s3_inst.str);

6505

}

6506

6507

static void

6508

s3_operand (expressionS * exp)

6509

{

6510

if (s3_in_my_get_expression)

6511

{

6512

exp->X_op = O_illegal;

6513

if (s3_inst.error == NULL)

6514

{

6515

s3_inst.error = _("bad expression");

6516

}

6517

}

6518

}

6519

6520

static void

6521

s3_begin (void)

6522

{

6523

unsigned int i;

6524

segT seg;

6525

subsegT subseg;

6526

6527

if ((s3_score_ops_hsh = hash_new ()) == NULL)

6528

as_fatal (_("virtual memory exhausted"));

6529

6530

s3_build_score_ops_hsh ();

6531

6532

if ((s3_dependency_insn_hsh = hash_new ()) == NULL)

6533

as_fatal (_("virtual memory exhausted"));

6534

6535

s3_build_dependency_insn_hsh ();

6536

6537

for (i = (int)s3_REG_TYPE_FIRST; i < (int)s3_REG_TYPE_MAX; i++)

6538

s3_build_reg_hsh (s3_all_reg_maps + i);

6539

6540

/* Initialize dependency vector. */

6541

s3_init_dependency_vector ();

6542

6543

bfd_set_arch_mach (stdoutput, TARGET_ARCH, 0);

6544

seg = now_seg;

6545

subseg = now_subseg;

6546

s3_pdr_seg = subseg_new (".pdr", (subsegT) 0);

6547

(void)bfd_set_section_flags (stdoutput, s3_pdr_seg, SEC_READONLY | SEC_RELOC | SEC_DEBUGGING);

6548

(void)bfd_set_section_alignment (stdoutput, s3_pdr_seg, 2);

6549

subseg_set (seg, subseg);

6550

6551

if (s3_USE_GLOBAL_POINTER_OPT)

6552

bfd_set_gp_size (stdoutput, s3_g_switch_value);

6553

}

6554

6555

static void

6556

s3_number_to_chars (char *buf, valueT val, int n)

6557

{

6558

if (target_big_endian)

6559

number_to_chars_bigendian (buf, val, n);

6560

else

6561

number_to_chars_littleendian (buf, val, n);

6562

}

6563

6564

static valueT

6565

s3_normal_chars_to_number (char *buf, int n)

6566

{

6567

valueT result = 0;

6568

unsigned char *where = (unsigned char *)buf;

6569

6570

if (target_big_endian)

6571

{

6572

while (n--)

6573

{

6574

result <<= 8;

6575

result |= (*where++ & 255);

6576

}

6577

}

6578

else

6579

{

6580

while (n--)

6581

{

6582

result <<= 8;

6583

result |= (where[n] & 255);

6584

}

6585

}

6586

6587

return result;

6588

}

6589

6590

static void

6591

s3_number_to_chars_littleendian (void *p, valueT data, int n)

6592

{

6593

char *buf = (char *) p;

6594

6595

switch (n)

6596

{

6597

case 4:

6598

md_number_to_chars (buf, data >> 16, 2);

6599

md_number_to_chars (buf + 2, data, 2);

6600

break;

6601

case 6:

6602

md_number_to_chars (buf, data >> 32, 2);

6603

md_number_to_chars (buf + 2, data >> 16, 2);

6604

md_number_to_chars (buf + 4, data, 2);

6605

break;

6606

default:

6607

/* Error routine. */

6608

as_bad_where (__FILE__, __LINE__, _("size is not 4 or 6"));

6609

break;

6610

}

6611

}

6612

6613

static valueT

6614

s3_chars_to_number_littleendian (const void *p, int n)

6615

{

6616

char *buf = (char *) p;

6617

valueT result = 0;

6618

6619

switch (n)

6620

{

6621

case 4:

6622

result = s3_normal_chars_to_number (buf, 2) << 16;

6623

result |= s3_normal_chars_to_number (buf + 2, 2);

6624

break;

6625

case 6:

6626

result = s3_normal_chars_to_number (buf, 2) << 32;

6627

result |= s3_normal_chars_to_number (buf + 2, 2) << 16;

6628

result |= s3_normal_chars_to_number (buf + 4, 2);

6629

break;

6630

default:

6631

/* Error routine. */

6632

as_bad_where (__FILE__, __LINE__, _("size is not 4 or 6"));

6633

break;

6634

}

6635

6636

return result;

6637

}

6638

6639

static void

6640

s3_md_number_to_chars (char *buf, valueT val, int n)

6641

{

6642

if (!target_big_endian && n >= 4)

6643

s3_number_to_chars_littleendian (buf, val, n);

6644

else

6645

md_number_to_chars (buf, val, n);

6646

}

6647

6648

static valueT

6649

s3_md_chars_to_number (char *buf, int n)

6650

{

6651

valueT result = 0;

6652

6653

if (!target_big_endian && n >= 4)

6654

result = s3_chars_to_number_littleendian (buf, n);

6655

else

6656

result = s3_normal_chars_to_number (buf, n);

6657

6658

return result;

6659

}

6660

6661

static char *

6662

s3_atof (int type, char *litP, int *sizeP)

6663

{

6664

int prec;

6665

LITTLENUM_TYPE words[s3_MAX_LITTLENUMS];

6666

char *t;

6667

int i;

6668

6669

switch (type)

6670

{

6671

case 'f':

6672

case 'F':

6673

case 's':

6674

case 'S':

6675

prec = 2;

6676

break;

6677

case 'd':

6678

case 'D':

6679

case 'r':

6680

case 'R':

6681

prec = 4;

6682

break;

6683

case 'x':

6684

case 'X':

6685

case 'p':

6686

case 'P':

6687

prec = 6;

6688

break;

6689

default:

6690

*sizeP = 0;

6691

return _("bad call to MD_ATOF()");

6692

}

6693

6694

t = atof_ieee (input_line_pointer, type, words);

6695

if (t)

6696

input_line_pointer = t;

6697

*sizeP = prec * 2;

6698

6699

if (target_big_endian)

6700

{

6701

for (i = 0; i < prec; i++)

6702

{

6703

s3_md_number_to_chars (litP, (valueT) words[i], 2);

6704

litP += 2;

6705

}

6706

}

6707

else

6708

{

6709

for (i = 0; i < prec; i += 2)

6710

{

6711

s3_md_number_to_chars (litP, (valueT) words[i + 1], 2);

6712

s3_md_number_to_chars (litP + 2, (valueT) words[i], 2);

6713

litP += 4;

6714

}

6715

}

6716

6717

return 0;

6718

}

6719

6720

static void

6721

s3_frag_check (fragS * fragp ATTRIBUTE_UNUSED)

6722

{

6723

know (fragp->insn_addr <= s3_RELAX_PAD_BYTE);

6724

}

6725

6726

static void

6727

s3_validate_fix (fixS *fixP)

6728

{

6729

fixP->fx_where += fixP->fx_frag->insn_addr;

6730

}

6731

6732

static int

6733

s3_force_relocation (struct fix *fixp)

6734

{

6735

int retval = 0;

6736

6737

if (fixp->fx_r_type == BFD_RELOC_VTABLE_INHERIT

6738

|| fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY

6739

|| fixp->fx_r_type == BFD_RELOC_SCORE_JMP

6740

|| fixp->fx_r_type == BFD_RELOC_SCORE_BRANCH

6741

|| fixp->fx_r_type == BFD_RELOC_SCORE16_JMP

6742

|| fixp->fx_r_type == BFD_RELOC_SCORE16_BRANCH

6743

|| fixp->fx_r_type == BFD_RELOC_SCORE_BCMP)

6744

{

6745

retval = 1;

6746

}

6747

return retval;

6748

}

6749

6750

static bfd_boolean

6751

s3_fix_adjustable (fixS * fixP)

6752

{

6753

if (fixP->fx_addsy == NULL)

6754

{

6755

return 1;

6756

}

6757

else if (OUTPUT_FLAVOR == bfd_target_elf_flavour

6758

&& (S_IS_EXTERNAL (fixP->fx_addsy) || S_IS_WEAK (fixP->fx_addsy)))

6759

{

6760

return 0;

6761

}

6762

else if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT

6763

|| fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY

6764

|| fixP->fx_r_type == BFD_RELOC_SCORE_JMP

6765

|| fixP->fx_r_type == BFD_RELOC_SCORE16_JMP)

6766

{

6767

return 0;

6768

}

6769

6770

return 1;

6771

}

6772

6773

static void

6774

s3_elf_final_processing (void)

6775

{

6776

unsigned long val = 0;

6777

6778

if (score3)

6779

val = E_SCORE_MACH_SCORE3;

6780

else if (score7)

6781

val = E_SCORE_MACH_SCORE7;

6782

6783

elf_elfheader (stdoutput)->e_machine = EM_SCORE;

6784

elf_elfheader (stdoutput)->e_flags &= ~EF_SCORE_MACH;

6785

elf_elfheader (stdoutput)->e_flags |= val;

6786

6787

if (s3_fix_data_dependency == 1)

6788

{

6789

elf_elfheader (stdoutput)->e_flags |= EF_SCORE_FIXDEP;

6790

}

6791

if (s3_score_pic == s3_PIC)

6792

{

6793

elf_elfheader (stdoutput)->e_flags |= EF_SCORE_PIC;

6794

}

6795

}

6796

6797

static int

6798

s3_judge_size_before_relax (fragS * fragp, asection *sec)

6799

{

6800

int change = 0;

6801

6802

if (s3_score_pic == s3_NO_PIC)

6803

change = s3_nopic_need_relax (fragp->fr_symbol, 0);

6804

else

6805

change = s3_pic_need_relax (fragp->fr_symbol, sec);

6806

6807

if (change == 1)

6808

{

6809

/* Only at the first time determining whether s3_GP instruction relax should be done,

6810

return the difference between insntruction size and instruction relax size. */

6811

if (fragp->fr_opcode == NULL)

6812

{

6813

fragp->fr_fix = s3_RELAX_NEW (fragp->fr_subtype);

6814

fragp->fr_opcode = fragp->fr_literal + s3_RELAX_RELOC1 (fragp->fr_subtype);

6815

return s3_RELAX_NEW (fragp->fr_subtype) - s3_RELAX_OLD (fragp->fr_subtype);

6816

}

6817

}

6818

6819

return 0;

6820

}

6821

6822

static int

6823

s3_estimate_size_before_relax (fragS * fragp, asection * sec ATTRIBUTE_UNUSED)

6824

{

6825

if ((s3_RELAX_TYPE (fragp->fr_subtype) == Insn_GP)

6826

|| (s3_RELAX_TYPE (fragp->fr_subtype) == Insn_PIC))

6827

return s3_judge_size_before_relax (fragp, sec);

6828

6829

return 0;

6830

}

6831

6832

static int

6833

s3_relax_branch_inst32 (fragS * fragp)

6834

{

6835

fragp->fr_opcode = NULL;

6836

return 0;

6837

}

6838

6839

static int

6840

s3_relax_branch_inst16 (fragS * fragp)

6841

{

6842

int relaxable_p = 0;

6843

int frag_addr = fragp->fr_address + fragp->insn_addr;

6844

addressT symbol_address = 0;

6845

symbolS *s;

6846

offsetT offset;

6847

long value;

6848

unsigned long inst_value;

6849

6850

relaxable_p = s3_RELAX_OPT (fragp->fr_subtype);

6851

6852

s = fragp->fr_symbol;

6853

if (s == NULL)

6854

frag_addr = 0;

6855

else

6856

{

6857

if (s->bsym != 0)

6858

symbol_address = (addressT) s->sy_frag->fr_address;

6859

}

6860

6861

inst_value = s3_md_chars_to_number (fragp->fr_literal, s3_INSN16_SIZE);

6862

offset = (inst_value & 0x1ff) << 1;

6863

if ((offset & 0x200) == 0x200)

6864

offset |= 0xfffffc00;

6865

6866

value = offset + symbol_address - frag_addr;

6867

6868

if (relaxable_p

6869

&& (!((value & 0xfffffe00) == 0 || (value & 0xfffffe00) == 0xfffffe00))

6870

&& fragp->fr_fix == 2

6871

&& (s->bsym != NULL)

6872

&& (S_IS_DEFINED (s)

6873

&& !S_IS_COMMON (s)

6874

&& !S_IS_EXTERNAL (s)))

6875

{

6876

/* Relax branch 32 to branch 16. */

6877

fragp->fr_opcode = fragp->fr_literal + s3_RELAX_RELOC1 (fragp->fr_subtype);

6878

fragp->fr_fix = 4;

6879

return 2;

6880

}

6881

else

6882

return 0;

6883

}

6884

6885

static int

6886

s3_relax_cmpbranch_inst32 (fragS * fragp)

6887

{

6888

int relaxable_p = 0;

6889

symbolS *s;

6890

/* For sign bit. */

6891

long offset;

6892

long frag_addr = fragp->fr_address + fragp->insn_addr;

6893

long symbol_address = 0;

6894

long value;

6895

unsigned long inst_value;

6896

6897

relaxable_p = s3_RELAX_OPT (fragp->fr_subtype);

6898

6899

s = fragp->fr_symbol;

6900

if (s == NULL)

6901

frag_addr = 0;

6902

else

6903

{

6904

if (s->bsym != 0)

6905

symbol_address = (addressT) s->sy_frag->fr_address;

6906

}

6907

6908

inst_value = s3_md_chars_to_number (fragp->fr_literal, s3_INSN_SIZE);

6909

offset = (inst_value & 0x1)

6910

| (((inst_value >> 7) & 0x7) << 1)

6911

| (((inst_value >> 21) & 0x1f) << 4);

6912

offset <<= 1;

6913

if ((offset & 0x200) == 0x200)

6914

offset |= 0xfffffe00;

6915

6916

value = offset + symbol_address - frag_addr;

6917

/* change the order of judging rule is because

6918

1.not defined symbol or common sysbol or external symbol will change

6919

bcmp to cmp!+beq/bne ,here need to record fragp->fr_opcode

6920

2.if the flow is as before : it will results to recursive loop

6921

6922

if (fragp->fr_fix == 6)

6923

{

6924

/* Have already relaxed! Just return 0 to terminate the loop. */

6925

return 0;

6926

}

6927

/* need to translate when extern or not defind or common sysbol */

6928

else if ((relaxable_p

6929

&& (!((value & 0xfffffe00) == 0 || (value & 0xfffffe00) == 0xfffffe00))

6930

&& fragp->fr_fix == 4

6931

&& (s->bsym != NULL))

6932

|| !S_IS_DEFINED (s)

6933

||S_IS_COMMON (s)

6934

||S_IS_EXTERNAL (s))

6935

{

6936

fragp->fr_opcode = fragp->fr_literal + s3_RELAX_RELOC1 (fragp->fr_subtype);

6937

fragp->fr_fix = 6;

6938

return 2;

6939

}

6940

else

6941

{

6942

/* Never relax. Modify fr_opcode to NULL to verify it's value in

6943

md_apply_fix. */

6944

fragp->fr_opcode = NULL;

6945

return 0;

6946

}

6947

}

6948

6949

6950

static int

6951

s3_relax_other_inst32 (fragS * fragp)

6952

{

6953

int relaxable_p = s3_RELAX_OPT (fragp->fr_subtype);

6954

6955

if (relaxable_p

6956

&& fragp->fr_fix == 4)

6957

{

6958

fragp->fr_opcode = fragp->fr_literal + s3_RELAX_RELOC1 (fragp->fr_subtype);

6959

fragp->fr_fix = 2;

6960

return -2;

6961

}

6962

else

6963

return 0;

6964

}

6965

6966

static int

6967

s3_relax_gp_and_pic_inst32 (void)

6968

{

6969

/* md_estimate_size_before_relax has already relaxed s3_GP and s3_PIC

6970

instructions. We don't change relax size here. */

6971

return 0;

6972

}

6973

6974

static int

6975

s3_relax_frag (asection * sec ATTRIBUTE_UNUSED, fragS * fragp, long stretch ATTRIBUTE_UNUSED)

6976

{

6977

int grows = 0;

6978

int adjust_align_p = 0;

6979

6980

/* If the instruction address is odd, make it half word align first. */

6981

if ((fragp->fr_address) % 2 != 0)

6982

{

6983

if ((fragp->fr_address + fragp->insn_addr) % 2 != 0)

6984

{

6985

fragp->insn_addr = 1;

6986

grows += 1;

6987

adjust_align_p = 1;

6988

}

6989

}

6990

6991

switch (s3_RELAX_TYPE (fragp->fr_subtype))

6992

{

6993

case PC_DISP19div2:

6994

grows += s3_relax_branch_inst32 (fragp);

6995

break;

6996

6997

case PC_DISP8div2:

6998

grows += s3_relax_branch_inst16 (fragp);

6999

break;

7000

7001

case Insn_BCMP :

7002

grows += s3_relax_cmpbranch_inst32 (fragp);

7003

break;

7004

7005

case Insn_GP:

7006

case Insn_PIC:

7007

grows += s3_relax_gp_and_pic_inst32 ();

7008

break;

7009

7010

default:

7011

grows += s3_relax_other_inst32 (fragp);

7012

break;

7013

}

7014

7015

/* newly added */

7016

if (adjust_align_p && fragp->insn_addr)

7017

{

7018

fragp->fr_fix += fragp->insn_addr;

7019

}

7020

7021

return grows;

7022

}

7023

7024

static void

7025

s3_convert_frag (bfd * abfd ATTRIBUTE_UNUSED, segT sec ATTRIBUTE_UNUSED, fragS * fragp)

7026

{

7027

int r_old;

7028

int r_new;

7029

char backup[20];

7030

fixS *fixp;

7031

7032

r_old = s3_RELAX_OLD (fragp->fr_subtype);

7033

r_new = s3_RELAX_NEW (fragp->fr_subtype);

7034

7035

/* fragp->fr_opcode indicates whether this frag should be relaxed. */

7036

if (fragp->fr_opcode == NULL)

7037

{

7038

memcpy (backup, fragp->fr_literal, r_old);

7039

fragp->fr_fix = r_old;

7040

}

7041

else

7042

{

7043

memcpy (backup, fragp->fr_literal + r_old, r_new);

7044

fragp->fr_fix = r_new;

7045

}

7046

7047

fixp = fragp->tc_frag_data.fixp;

7048

while (fixp && fixp->fx_frag == fragp && fixp->fx_where < r_old)

7049

{

7050

if (fragp->fr_opcode)

7051

fixp->fx_done = 1;

7052

fixp = fixp->fx_next;

7053

}

7054

while (fixp && fixp->fx_frag == fragp)

7055

{

7056

if (fragp->fr_opcode)

7057

fixp->fx_where -= r_old + fragp->insn_addr;

7058

else

7059

fixp->fx_done = 1;

7060

fixp = fixp->fx_next;

7061

}

7062

7063

if (fragp->insn_addr)

7064

{

7065

s3_md_number_to_chars (fragp->fr_literal, 0x0, fragp->insn_addr);

7066

}

7067

memcpy (fragp->fr_literal + fragp->insn_addr, backup, fragp->fr_fix);

7068

fragp->fr_fix += fragp->insn_addr;

7069

}

7070

7071

static long

7072

s3_pcrel_from (fixS * fixP)

7073

{

7074

long retval = 0;

7075

7076

if (fixP->fx_addsy

7077

&& (S_GET_SEGMENT (fixP->fx_addsy) == undefined_section)

7078

&& (fixP->fx_subsy == NULL))

7079

{

7080

retval = 0;

7081

}

7082

else

7083

{

7084

retval = fixP->fx_where + fixP->fx_frag->fr_address;

7085

}

7086

7087

return retval;

7088

}

7089

7090

static valueT

7091

s3_section_align (segT segment ATTRIBUTE_UNUSED, valueT size)

7092

{

7093

int align = bfd_get_section_alignment (stdoutput, segment);

7094

return ((size + (1 << align) - 1) & (-1 << align));

7095

}

7096

7097

static void

7098

s3_apply_fix (fixS *fixP, valueT *valP, segT seg)

7099

{

7100

offsetT value = *valP;

7101

offsetT newval;

7102

offsetT content;

7103

unsigned short HI, LO;

7104

7105

char *buf = fixP->fx_frag->fr_literal + fixP->fx_where;

7106

7107

gas_assert (fixP->fx_r_type < BFD_RELOC_UNUSED);

7108

if (fixP->fx_addsy == 0 && !fixP->fx_pcrel)

7109

{

7110

if (fixP->fx_r_type != BFD_RELOC_SCORE_DUMMY_HI16)

7111

fixP->fx_done = 1;

7112

}

7113

7114

/* If this symbol is in a different section then we need to leave it for

7115

the linker to deal with. Unfortunately, md_pcrel_from can't tell,

7116

so we have to undo it's effects here. */

7117

if (fixP->fx_pcrel)

7118

{

7119

if (fixP->fx_addsy != NULL

7120

&& S_IS_DEFINED (fixP->fx_addsy)

7121

&& S_GET_SEGMENT (fixP->fx_addsy) != seg)

7122

value += md_pcrel_from (fixP);

7123

}

7124

7125

/* Remember value for emit_reloc. */

7126

fixP->fx_addnumber = value;

7127

7128

switch (fixP->fx_r_type)

7129

{

7130

case BFD_RELOC_HI16_S:

7131

if (fixP->fx_done) /* For la rd, imm32. */

7132

{

7133

newval = s3_md_chars_to_number (buf, s3_INSN_SIZE);

7134

HI = (value) >> 16; /* mul to 2, then take the hi 16 bit. */

7135

newval |= (HI & 0x3fff) << 1;

7136

newval |= ((HI >> 14) & 0x3) << 16;

7137

s3_md_number_to_chars (buf, newval, s3_INSN_SIZE);

7138

}

7139

break;

7140

case BFD_RELOC_LO16:

7141

if (fixP->fx_done) /* For la rd, imm32. */

7142

{

7143

newval = s3_md_chars_to_number (buf, s3_INSN_SIZE);

7144

LO = (value) & 0xffff;

7145

newval |= (LO & 0x3fff) << 1; /* 16 bit: imm -> 14 bit in lo, 2 bit in hi. */

7146

newval |= ((LO >> 14) & 0x3) << 16;

7147

s3_md_number_to_chars (buf, newval, s3_INSN_SIZE);

7148

}

7149

break;

7150

case BFD_RELOC_SCORE_JMP:

7151

{

7152

content = s3_md_chars_to_number (buf, s3_INSN_SIZE);

7153

value = fixP->fx_offset;

7154

content = (content & ~0x3ff7ffe) | ((value << 1) & 0x3ff0000) | (value & 0x7fff);

7155

s3_md_number_to_chars (buf, content, s3_INSN_SIZE);

7156

}

7157

break;

7158

7159

case BFD_RELOC_SCORE_IMM30:

7160

{

7161

content = s3_md_chars_to_number (buf, s3_INSN48_SIZE);

7162

value = fixP->fx_offset;

7163

value >>= 2;

7164

content = (content & ~0x7f7fff7f80LL)

7165

| (((value & 0xff) >> 0) << 7)

7166

| (((value & 0x7fff00) >> 8) << 16)

7167

| (((value & 0x3f800000) >> 23) << 32);

7168

s3_md_number_to_chars (buf, content, s3_INSN48_SIZE);

7169

break;

7170

}

7171

7172

case BFD_RELOC_SCORE_IMM32:

7173

{

7174

content = s3_md_chars_to_number (buf, s3_INSN48_SIZE);

7175

value = fixP->fx_offset;

7176

content = (content & ~0x7f7fff7fe0LL)

7177

| ((value & 0x3ff) << 5)

7178

| (((value >> 10) & 0x7fff) << 16)

7179

| (((value >> 25) & 0x7f) << 32);

7180

s3_md_number_to_chars (buf, content, s3_INSN48_SIZE);

7181

break;

7182

}

7183

7184

case BFD_RELOC_SCORE_BRANCH:

7185

if ((S_GET_SEGMENT (fixP->fx_addsy) != seg) || (fixP->fx_addsy != NULL && S_IS_EXTERNAL (fixP->fx_addsy)))

7186

value = fixP->fx_offset;

7187

else

7188

fixP->fx_done = 1;

7189

7190

content = s3_md_chars_to_number (buf, s3_INSN_SIZE);

7191

7192

/* Don't check c-bit. */

7193

if (fixP->fx_frag->fr_opcode != 0)

7194

{

7195

if ((value & 0xfffffe00) != 0 && (value & 0xfffffe00) != 0xfffffe00)

7196

{

7197

as_bad_where (fixP->fx_file, fixP->fx_line,

7198

_(" branch relocation truncate (0x%x) [-2^9 ~ 2^9]"), (unsigned int)value);

7199

return;

7200

}

7201

content = s3_md_chars_to_number (buf, s3_INSN16_SIZE);

7202

content &= 0xfe00;

7203

content = (content & 0xfe00) | ((value >> 1) & 0x1ff);

7204

s3_md_number_to_chars (buf, content, s3_INSN16_SIZE);

7205

fixP->fx_r_type = BFD_RELOC_SCORE16_BRANCH;

7206

fixP->fx_size = 2;

7207

}

7208

else

7209

{

7210

if ((value & 0xfff80000) != 0 && (value & 0xfff80000) != 0xfff80000)

7211

{

7212

as_bad_where (fixP->fx_file, fixP->fx_line,

7213

_(" branch relocation truncate (0x%x) [-2^19 ~ 2^19]"), (unsigned int)value);

7214

return;

7215

}

7216

content = s3_md_chars_to_number (buf, s3_INSN_SIZE);

7217

content &= 0xfc00fc01;

7218

content = (content & 0xfc00fc01) | (value & 0x3fe) | ((value << 6) & 0x3ff0000);

7219

s3_md_number_to_chars (buf, content, s3_INSN_SIZE);

7220

}

7221

break;

7222

case BFD_RELOC_SCORE16_JMP:

7223

content = s3_md_chars_to_number (buf, s3_INSN16_SIZE);

7224

content &= 0xf001;

7225

value = fixP->fx_offset & 0xfff;

7226

content = (content & 0xfc01) | (value & 0xffe);

7227

s3_md_number_to_chars (buf, content, s3_INSN16_SIZE);

7228

break;

7229

case BFD_RELOC_SCORE16_BRANCH:

7230

content = s3_md_chars_to_number (buf, s3_INSN_SIZE);

7231

/* Don't check c-bit. */

7232

if (fixP->fx_frag->fr_opcode != 0)

7233

{

7234

if ((S_GET_SEGMENT (fixP->fx_addsy) != seg) ||

7235

(fixP->fx_addsy != NULL && S_IS_EXTERNAL (fixP->fx_addsy)))

7236

value = fixP->fx_offset;

7237

else

7238

fixP->fx_done = 1;

7239

if ((value & 0xfff80000) != 0 && (value & 0xfff80000) != 0xfff80000)

7240

{

7241

as_bad_where (fixP->fx_file, fixP->fx_line,

7242

_(" branch relocation truncate (0x%x) [-2^19 ~ 2^19]"), (unsigned int)value);

7243

return;

7244

}

7245

content = s3_md_chars_to_number (buf, s3_INSN_SIZE);

7246

content = (content & 0xfc00fc01) | (value & 0x3fe) | ((value << 6) & 0x3ff0000);

7247

s3_md_number_to_chars (buf, content, s3_INSN_SIZE);

7248

fixP->fx_r_type = BFD_RELOC_SCORE_BRANCH;

7249

fixP->fx_size = 4;

7250

break;

7251

}

7252

else

7253

{

7254

/* In differnt section. */

7255

if ((S_GET_SEGMENT (fixP->fx_addsy) != seg) ||

7256

(fixP->fx_addsy != NULL && S_IS_EXTERNAL (fixP->fx_addsy)))

7257

value = fixP->fx_offset;

7258

else

7259

fixP->fx_done = 1;

7260

7261

if ((value & 0xfffffe00) != 0 && (value & 0xfffffe00) != 0xfffffe00)

7262

{

7263

as_bad_where (fixP->fx_file, fixP->fx_line,

7264

_(" branch relocation truncate (0x%x) [-2^9 ~ 2^9]"), (unsigned int)value);

7265

return;

7266

}

7267

7268

content = s3_md_chars_to_number (buf, s3_INSN16_SIZE);

7269

content = (content & 0xfe00) | ((value >> 1) & 0x1ff);

7270

s3_md_number_to_chars (buf, content, s3_INSN16_SIZE);

7271

break;

7272

}

7273

7274

break;

7275

7276

case BFD_RELOC_SCORE_BCMP:

7277

if (fixP->fx_frag->fr_opcode != 0)

7278

{

7279

char *buf_ptr = buf;

7280

buf_ptr += 2;

7281

7282

if ((S_GET_SEGMENT (fixP->fx_addsy) != seg) || (fixP->fx_addsy != NULL && S_IS_EXTERNAL (fixP->fx_addsy)))

7283

value = fixP->fx_offset;

7284

else

7285

fixP->fx_done = 1;

7286

7287

/* NOTE!!!

7288

bcmp -> cmp! and branch, so value -= 2. */

7289

value -= 2;

7290

7291

if ((value & 0xfff80000) != 0 && (value & 0xfff80000) != 0xfff80000)

7292

{

7293

as_bad_where (fixP->fx_file, fixP->fx_line,

7294

_(" branch relocation truncate (0x%x) [-2^19 ~ 2^19]"), (unsigned int)value);

7295

return;

7296

}

7297

7298

content = s3_md_chars_to_number (buf_ptr, s3_INSN_SIZE);

7299

content &= 0xfc00fc01;

7300

content = (content & 0xfc00fc01) | (value & 0x3fe) | ((value << 6) & 0x3ff0000);

7301

s3_md_number_to_chars (buf_ptr, content, s3_INSN_SIZE);

7302

/* change relocation type to BFD_RELOC_SCORE_BRANCH */

7303

fixP->fx_r_type = BFD_RELOC_SCORE_BRANCH;

7304

fixP->fx_where+=2; /* first insn is cmp! , the second insn is beq/bne */

7305

break;

7306

}

7307

else

7308

{

7309

if ((S_GET_SEGMENT (fixP->fx_addsy) != seg) || (fixP->fx_addsy != NULL && S_IS_EXTERNAL (fixP->fx_addsy)))

7310

value = fixP->fx_offset;

7311

else

7312

fixP->fx_done = 1;

7313

7314

content = s3_md_chars_to_number (buf, s3_INSN_SIZE);

7315

7316

if ((value & 0xfffffe00) != 0 && (value & 0xfffffe00) != 0xfffffe00)

7317

{

7318

as_bad_where (fixP->fx_file, fixP->fx_line,

7319

_(" branch relocation truncate (0x%x) [-2^9 ~ 2^9]"), (unsigned int)value);

7320

return;

7321

}

7322

7323

value >>= 1;

7324

content &= ~0x03e00381;

7325

content = content

7326

| (value & 0x1)

7327

| (((value & 0xe) >> 1) << 7)

7328

| (((value & 0x1f0) >> 4) << 21);

7329

7330

s3_md_number_to_chars (buf, content, s3_INSN_SIZE);

7331

break;

7332

}

7333

7334

case BFD_RELOC_8:

7335

if (fixP->fx_done || fixP->fx_pcrel)

7336

s3_md_number_to_chars (buf, value, 1);

7337

#ifdef OBJ_ELF

7338

else

7339

{

7340

value = fixP->fx_offset;

7341

s3_md_number_to_chars (buf, value, 1);

7342

}

7343

#endif

7344

break;

7345

7346

case BFD_RELOC_16:

7347

if (fixP->fx_done || fixP->fx_pcrel)

7348

s3_md_number_to_chars (buf, value, 2);

7349

#ifdef OBJ_ELF

7350

else

7351

{

7352

value = fixP->fx_offset;

7353

s3_md_number_to_chars (buf, value, 2);

7354

}

7355

#endif

7356

break;

7357

case BFD_RELOC_RVA:

7358

case BFD_RELOC_32:

7359

if (fixP->fx_done || fixP->fx_pcrel)

7360

md_number_to_chars (buf, value, 4);

7361

#ifdef OBJ_ELF

7362

else

7363

{

7364

value = fixP->fx_offset;

7365

md_number_to_chars (buf, value, 4);

7366

}

7367

#endif

7368

break;

7369

case BFD_RELOC_VTABLE_INHERIT:

7370

fixP->fx_done = 0;

7371

if (fixP->fx_addsy && !S_IS_DEFINED (fixP->fx_addsy) && !S_IS_WEAK (fixP->fx_addsy))

7372

S_SET_WEAK (fixP->fx_addsy);

7373

break;

7374

case BFD_RELOC_VTABLE_ENTRY:

7375

fixP->fx_done = 0;

7376

break;

7377

case BFD_RELOC_SCORE_GPREL15:

7378

content = s3_md_chars_to_number (buf, s3_INSN_SIZE);

7379

/* c-bit. */

7380

if ((fixP->fx_frag->fr_opcode != 0) && ((content & 0xfc1c8000) != 0x94180000))

7381

fixP->fx_r_type = BFD_RELOC_NONE;

7382

fixP->fx_done = 0;

7383

break;

7384

case BFD_RELOC_SCORE_GOT15:

7385

case BFD_RELOC_SCORE_DUMMY_HI16:

7386

case BFD_RELOC_SCORE_GOT_LO16:

7387

case BFD_RELOC_SCORE_CALL15:

7388

case BFD_RELOC_GPREL32:

7389

break;

7390

case BFD_RELOC_NONE:

7391

default:

7392

as_bad_where (fixP->fx_file, fixP->fx_line, _("bad relocation fixup type (%d)"), fixP->fx_r_type);

7393

}

7394

}

7395

7396

static arelent **

7397

s3_gen_reloc (asection * section ATTRIBUTE_UNUSED, fixS * fixp)

7398

{

7399

static arelent *retval[MAX_RELOC_EXPANSION + 1]; /* MAX_RELOC_EXPANSION equals 2. */

7400

arelent *reloc;

7401

bfd_reloc_code_real_type code;

7402

char *type;

7403

7404

reloc = retval[0] = xmalloc (sizeof (arelent));

7405

retval[1] = NULL;

7406

7407

reloc->sym_ptr_ptr = xmalloc (sizeof (asymbol *));

7408

*reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);

7409

reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;

7410

reloc->addend = fixp->fx_offset;

7411

7412

/* If this is a variant frag, we may need to adjust the existing

7413

reloc and generate a new one. */

7414

if (fixp->fx_frag->fr_opcode != NULL && (fixp->fx_r_type == BFD_RELOC_SCORE_GPREL15))

7415

{

7416

/* Update instruction imm bit. */

7417

offsetT newval;

7418

unsigned short off;

7419

char *buf;

7420

7421

buf = fixp->fx_frag->fr_literal + fixp->fx_frag->insn_addr;

7422

newval = s3_md_chars_to_number (buf, s3_INSN_SIZE);

7423

off = fixp->fx_offset >> 16;

7424

newval |= (off & 0x3fff) << 1;

7425

newval |= ((off >> 14) & 0x3) << 16;

7426

s3_md_number_to_chars (buf, newval, s3_INSN_SIZE);

7427

7428

buf += s3_INSN_SIZE;

7429

newval = s3_md_chars_to_number (buf, s3_INSN_SIZE);

7430

off = fixp->fx_offset & 0xffff;

7431

newval |= ((off & 0x3fff) << 1);

7432

newval |= (((off >> 14) & 0x3) << 16);

7433

s3_md_number_to_chars (buf, newval, s3_INSN_SIZE);

7434

7435

retval[1] = xmalloc (sizeof (arelent));

7436

retval[2] = NULL;

7437

retval[1]->sym_ptr_ptr = xmalloc (sizeof (asymbol *));

7438

*retval[1]->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);

7439

retval[1]->address = (reloc->address + s3_RELAX_RELOC2 (fixp->fx_frag->fr_subtype));

7440

7441

retval[1]->addend = 0;

7442

retval[1]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_LO16);

7443

gas_assert (retval[1]->howto != NULL);

7444

7445

fixp->fx_r_type = BFD_RELOC_HI16_S;

7446

}

7447

7448

code = fixp->fx_r_type;

7449

switch (fixp->fx_r_type)

7450

{

7451

case BFD_RELOC_32:

7452

if (fixp->fx_pcrel)

7453

{

7454

code = BFD_RELOC_32_PCREL;

7455

break;

7456

}

7457

case BFD_RELOC_HI16_S:

7458

case BFD_RELOC_LO16:

7459

case BFD_RELOC_SCORE_JMP:

7460

case BFD_RELOC_SCORE_BRANCH:

7461

case BFD_RELOC_SCORE16_JMP:

7462

case BFD_RELOC_SCORE16_BRANCH:

7463

case BFD_RELOC_SCORE_BCMP:

7464

case BFD_RELOC_VTABLE_ENTRY:

7465

case BFD_RELOC_VTABLE_INHERIT:

7466

case BFD_RELOC_SCORE_GPREL15:

7467

case BFD_RELOC_SCORE_GOT15:

7468

case BFD_RELOC_SCORE_DUMMY_HI16:

7469

case BFD_RELOC_SCORE_GOT_LO16:

7470

case BFD_RELOC_SCORE_CALL15:

7471

case BFD_RELOC_GPREL32:

7472

case BFD_RELOC_NONE:

7473

case BFD_RELOC_SCORE_IMM30:

7474

case BFD_RELOC_SCORE_IMM32:

7475

code = fixp->fx_r_type;

7476

break;

7477

default:

7478

type = _("<unknown>");

7479

as_bad_where (fixp->fx_file, fixp->fx_line,

7480

_("cannot represent %s relocation in this object file format"), type);

7481

return NULL;

7482

}

7483

7484

reloc->howto = bfd_reloc_type_lookup (stdoutput, code);

7485

if (reloc->howto == NULL)

7486

{

7487

as_bad_where (fixp->fx_file, fixp->fx_line,

7488

_("cannot represent %s relocation in this object file format1"),

7489

bfd_get_reloc_code_name (code));

7490

return NULL;

7491

}

7492

/* HACK: Since arm ELF uses Rel instead of Rela, encode the

7493

vtable entry to be used in the relocation's section offset. */

7494

if (fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)

7495

reloc->address = fixp->fx_offset;

7496

7497

return retval;

7498

}

7499

7500

void

7501

md_assemble (char *str)

7502

{

7503

if (score3)

7504

s3_assemble (str);

7505

else

7506

s7_assemble (str);

7507

}

7508

7509

/* We handle all bad expressions here, so that we can report the faulty

7510

instruction in the error message. */

7511

void

7512

md_operand (expressionS * exp)

7513

{

7514

if (score3)

7515

s3_operand (exp);

7516

else

7517

s7_operand (exp);

7518

}

7519

7520

/* Turn an integer of n bytes (in val) into a stream of bytes appropriate

7521

for use in the a.out file, and stores them in the array pointed to by buf.

7522

This knows about the endian-ness of the target machine and does

7523

THE RIGHT THING, whatever it is. Possible values for n are 1 (byte)

7524

2 (short) and 4 (long) Floating numbers are put out as a series of

7525

LITTLENUMS (shorts, here at least). */

7526

void

7527

md_number_to_chars (char *buf, valueT val, int n)

7528

{

7529

if (score3)

7530

s3_number_to_chars (buf, val, n);

7531

else

7532

s7_number_to_chars (buf, val, n);

7533

}

7534

7535

/* Turn a string in input_line_pointer into a floating point constant

7536

of type TYPE, and store the appropriate bytes in *LITP. The number

7537

of LITTLENUMS emitted is stored in *SIZEP. An error message is

7538

returned, or NULL on OK.

7539

7540

Note that fp constants aren't represent in the normal way on the ARM.

7541

In big endian mode, things are as expected. However, in little endian

7542

mode fp constants are big-endian word-wise, and little-endian byte-wise

7543

within the words. For example, (double) 1.1 in big endian mode is

7544

the byte sequence 3f f1 99 99 99 99 99 9a, and in little endian mode is

7545

the byte sequence 99 99 f1 3f 9a 99 99 99. */

7546

char *

7547

md_atof (int type, char *litP, int *sizeP)

7548

{

7549

if (score3)

7550

return s3_atof (type, litP, sizeP);

7551

else

7552

return s7_atof (type, litP, sizeP);

7553

}

7554

7555

void

7556

score_frag_check (fragS * fragp ATTRIBUTE_UNUSED)

7557

{

7558

if (score3)

7559

s3_frag_check (fragp);

7560

else

7561

s7_frag_check (fragp);

7562

}

7563

7564

/* Implementation of TC_VALIDATE_FIX.

7565

Called before md_apply_fix() and after md_convert_frag(). */

7566

void

7567

score_validate_fix (fixS *fixP)

7568

{

7569

if (score3)

7570

s3_validate_fix (fixP);

7571

else

7572

s7_validate_fix (fixP);

7573

}

7574

7575

int

7576

score_force_relocation (struct fix *fixp)

7577

{

7578

if (score3)

7579

return s3_force_relocation (fixp);

7580

else

7581

return s7_force_relocation (fixp);

7582

}

7583

7584

/* Implementation of md_frag_check.

7585

Called after md_convert_frag(). */

7586

bfd_boolean

7587

score_fix_adjustable (fixS * fixP)

7588

{

7589

if (score3)

7590

return s3_fix_adjustable (fixP);

7591

else

7592

return s7_fix_adjustable (fixP);

7593

}

7594

7595

void

7596

score_elf_final_processing (void)

7597

{

7598

if (score3)

7599

s3_elf_final_processing ();

7600

else

7601

s7_elf_final_processing ();

7602

}

7603

7604

/* In this function, we determine whether s3_GP instruction should do relaxation,

7605

for the label being against was known now.

7606

Doing this here but not in md_relax_frag() can induce iteration times

7607

in stage of doing relax. */

7608

int

7609

md_estimate_size_before_relax (fragS * fragp, asection * sec ATTRIBUTE_UNUSED)

7610

{

7611

if (score3)

7612

return s3_estimate_size_before_relax (fragp, sec);

7613

else

7614

return s7_estimate_size_before_relax (fragp, sec);

7615

}

7616

7617

int

7618

score_relax_frag (asection * sec ATTRIBUTE_UNUSED, fragS * fragp, long stretch ATTRIBUTE_UNUSED)

7619

{

7620

if (score3)

7621

return s3_relax_frag (sec, fragp, stretch);

7622

else

7623

return s7_relax_frag (sec, fragp, stretch);

7624

}

7625

7626

void

7627

md_convert_frag (bfd * abfd ATTRIBUTE_UNUSED, segT sec ATTRIBUTE_UNUSED, fragS * fragp)

7628

{

7629

if (score3)

7630

return s3_convert_frag (abfd, sec, fragp);

7631

else

7632

return s7_convert_frag (abfd, sec, fragp);

7633

}

7634

7635

long

7636

md_pcrel_from (fixS * fixP)

7637

{

7638

if (score3)

7639

return s3_pcrel_from (fixP);

7640

else

7641

return s7_pcrel_from (fixP);

7642

}

7643

7644

/* Round up a section size to the appropriate boundary. */

7645

valueT

7646

md_section_align (segT segment ATTRIBUTE_UNUSED, valueT size)

7647

{

7648

if (score3)

7649

return s3_section_align (segment, size);

7650

else

7651

return s7_section_align (segment, size);

7652

}

7653

7654

void

7655

md_apply_fix (fixS *fixP, valueT *valP, segT seg)

7656

{

7657

if (score3)

7658

return s3_apply_fix (fixP, valP, seg);

7659

else

7660

return s7_apply_fix (fixP, valP, seg);

7661

}

7662

7663

/* Translate internal representation of relocation info to BFD target format. */

7664

arelent **

7665

tc_gen_reloc (asection * section ATTRIBUTE_UNUSED, fixS * fixp)

7666

{

7667

if (score3)

7668

return s3_gen_reloc (section, fixp);

7669

else

7670

return s7_gen_reloc (section, fixp);

7671

}

7672

7673

void

7674

md_begin (void)

7675

{

7676

s3_begin ();

7677

s7_begin ();

7678

}

7679

7680

static void

7681

score_set_mach (const char *arg)

7682

{

7683

if (strcmp (arg, MARCH_SCORE3) == 0)

7684

{

7685

score3 = 1;

7686

score7 = 0;

7687

s3_score3d = 1;

7688

}

7689

else if (strcmp (arg, MARCH_SCORE7) == 0)

7690

{

7691

score3 = 0;

7692

score7 = 1;

7693

s7_score7d = 1;

7694

s7_university_version = 0;

7695

s7_vector_size = s7_SCORE7_PIPELINE;

7696

}

7697

else if (strcmp (arg, MARCH_SCORE5) == 0)

7698

{

7699

score3 = 0;

7700

score7 = 1;

7701

s7_score7d = 1;

7702

s7_university_version = 0;

7703

s7_vector_size = s7_SCORE5_PIPELINE;

7704

}

7705

else if (strcmp (arg, MARCH_SCORE5U) == 0)

7706

{

7707

score3 = 0;

7708

score7 = 1;

7709

s7_score7d = 1;

7710

s7_university_version = 1;

7711

s7_vector_size = s7_SCORE5_PIPELINE;

7712

}

7713

else

7714

{

7715

as_bad (_("unknown architecture `%s'\n"), arg);

7716

}

7717

}

7718

7719

int

7720

md_parse_option (int c, char *arg)

7721

{

7722

switch (c)

7723

{

7724

#ifdef OPTION_EB

7725

case OPTION_EB:

7726

target_big_endian = 1;

7727

break;

7728

#endif

7729

#ifdef OPTION_EL

7730

case OPTION_EL:

7731

target_big_endian = 0;

7732

break;

7733

#endif

7734

case OPTION_FIXDD:

7735

s3_fix_data_dependency = 1;

7736

s7_fix_data_dependency = 1;

7737

break;

7738

case OPTION_NWARN:

7739

s3_warn_fix_data_dependency = 0;

7740

s7_warn_fix_data_dependency = 0;

7741

break;

7742

case OPTION_SCORE5:

7743

score3 = 0;

7744

score7 = 1;

7745

s7_university_version = 0;

7746

s7_vector_size = s7_SCORE5_PIPELINE;

7747

break;

7748

case OPTION_SCORE5U:

7749

score3 = 0;

7750

score7 = 1;

7751

s7_university_version = 1;

7752

s7_vector_size = s7_SCORE5_PIPELINE;

7753

break;

7754

case OPTION_SCORE7:

7755

score3 = 0;

7756

score7 = 1;

7757

s7_score7d = 1;

7758

s7_university_version = 0;

7759

s7_vector_size = s7_SCORE7_PIPELINE;

7760

break;

7761

case OPTION_SCORE3:

7762

score3 = 1;

7763

score7 = 0;

7764

s3_score3d = 1;

7765

break;

7766

case OPTION_R1:

7767

s3_nor1 = 0;

7768

s7_nor1 = 0;

7769

break;

7770

case 'G':

7771

s3_g_switch_value = atoi (arg);

7772

s7_g_switch_value = atoi (arg);

7773

break;

7774

case OPTION_O0:

7775

s3_g_opt = 0;

7776

s7_g_opt = 0;

7777

break;

7778

case OPTION_SCORE_VERSION:

7779

printf (_("Sunplus-v2-0-0-20060510\n"));

7780

break;

7781

case OPTION_PIC:

7782

s3_score_pic = s3_NO_PIC; /* Score3 doesn't support PIC now. */

7783

s7_score_pic = s7_PIC;

7784

s3_g_switch_value = 0; /* Must set -G num as 0 to generate s3_PIC code. */

7785

s7_g_switch_value = 0; /* Must set -G num as 0 to generate s7_PIC code. */

7786

break;

7787

case OPTION_MARCH:

7788

score_set_mach (arg);

7789

break;

7790

default:

7791

return 0;

7792

}

7793

return 1;

7794

}

7795

7796

void

7797

md_show_usage (FILE * fp)

7798

{

7799

fprintf (fp, _(" Score-specific assembler options:\n"));

7800

#ifdef OPTION_EB

7801

fprintf (fp, _("\

7802

-EB\t\tassemble code for a big-endian cpu\n"));

7803

#endif

7804

7805

#ifdef OPTION_EL

7806

fprintf (fp, _("\

7807

-EL\t\tassemble code for a little-endian cpu\n"));

7808

#endif

7809

7810

fprintf (fp, _("\

7811

-FIXDD\t\tassemble code for fix data dependency\n"));

7812

fprintf (fp, _("\

7813

-NWARN\t\tassemble code for no warning message for fix data dependency\n"));

7814

fprintf (fp, _("\

7815

-SCORE5\t\tassemble code for target is SCORE5\n"));

7816

fprintf (fp, _("\

7817

-SCORE5U\tassemble code for target is SCORE5U\n"));

7818

fprintf (fp, _("\

7819

-SCORE7\t\tassemble code for target is SCORE7, this is default setting\n"));

7820

fprintf (fp, _("\

7821

-SCORE3\t\tassemble code for target is SCORE3\n"));

7822

fprintf (fp, _("\

7823

-march=score7\tassemble code for target is SCORE7, this is default setting\n"));

7824

fprintf (fp, _("\

7825

-march=score3\tassemble code for target is SCORE3\n"));

7826

fprintf (fp, _("\

7827

-USE_R1\t\tassemble code for no warning message when using temp register r1\n"));

7828

fprintf (fp, _("\

7829

-KPIC\t\tassemble code for PIC\n"));

7830

fprintf (fp, _("\

7831

-O0\t\tassembler will not perform any optimizations\n"));

7832

fprintf (fp, _("\

7833

-G gpnum\tassemble code for setting gpsize and default is 8 byte\n"));

7834

fprintf (fp, _("\

7835

-V \t\tSunplus release version \n"));

7836

}

Older »