RE: [RFA] New port: CR16: BFD Changes required by the gdb port

Kaushik Phatak
2012-12-28T12:18:31Z

Hi Pedro,
Thanks for taking out time to review this.

> It'd be nice if all these exported symbols were prefixed, to avoid
> namespace collisions.

I have added 'cr16_' as a prefix to all these exported symbols.
I have also fixed the 80-char limit for lines affected by this change.
Please let me know if the below changes are ok.

Thanks & Best Regards,
Kaushik

2012-12-28 Kaushik Phatak <kaushik.phatak@kpitcummins.com>
opcodes/ChangeLog
* cr16-dis.c (match_opcode,make_instruction: Remove static declaration.
(dwordU,wordU): Moved typedefs to opcode/cr16.h
(cr16_words,cr16_allWords,cr16_currInsn): Added prefix 'cr16_'

bfd/Changelog
* config.bfd (cr16*-*-uclinux*): New target support.

include/opcode/ChangeLog
* cr16.h (dwordU,wordU): Moved typedefs from cr16-dis.c
(make_instruction,match_opcode): Added function prototypes.
(cr16_words,cr16_allWords,cr16_currInsn): Declare as extern.

diff -uprN ./gdb_src.orig/opcodes/cr16-dis.c ./gdb_src/opcodes/cr16-dis.c
--- ./gdb_src.orig/opcodes/cr16-dis.c 2012-05-17 20:43:25.000000000 +0530
+++ ./gdb_src/opcodes/cr16-dis.c 2012-12-28 17:24:14.000000000 +0530
@@ -36,9 +36,6 @@
/* Set Bit Mask - a mask to set all bits starting from offset 'offs'. */
#define SBM(offs) ((((1 << (32 - offs)) -1) << (offs)))

-typedef unsigned long dwordU;
-typedef unsigned short wordU;
-
typedef struct
{
dwordU val;
@@ -83,11 +80,11 @@ REG_ARG_TYPE;
/* Current opcode table entry we're disassembling. */
const inst *instruction;
/* Current instruction we're disassembling. */
-ins currInsn;
+ins cr16_currInsn;
/* The current instruction is read into 3 consecutive words. */
-wordU words[3];
+wordU cr16_words[3];
/* Contains all words in appropriate order. */
-ULONGLONG allWords;
+ULONGLONG cr16_allWords;
/* Holds the current processed argument number. */
int processing_argument_number;
/* Nonzero means a IMM4 instruction. */
@@ -281,7 +278,7 @@ getprocpregname (int reg_index)
return "ILLEGAL REGISTER";
}

-/* START and END are relating 'allWords' struct, which is 48 bits size.
+/* START and END are relating 'cr16_allWords' struct, which is 48 bits size.

START|--------|END
+---------+---------+---------+---------+
@@ -317,12 +314,13 @@ build_mask (void)

/* Search for a matching opcode. Return 1 for success, 0 for failure. */

-static int
+int
match_opcode (void)
{
unsigned long mask;
/* The instruction 'constant' opcode doewsn't exceed 32 bits. */
- unsigned long doubleWord = (words[1] + (words[0] << 16)) & 0xffffffff;
+ unsigned long doubleWord = (cr16_words[1]
+ + (cr16_words[0] << 16)) & 0xffffffff;

/* Start searching from end of instruction table. */
instruction = &cr16_instruction[NUMOPCODES - 2];
@@ -360,38 +358,44 @@ make_argument (argument * a, int start_b
switch (a->type)
{
case arg_r:
- p = makelongparameter (allWords, inst_bit_size - (start_bits + a->size),
- inst_bit_size - start_bits);
+ p = makelongparameter (cr16_allWords,
+ inst_bit_size - (start_bits + a->size),
+ inst_bit_size - start_bits);
a->r = p.val;
break;

case arg_rp:
- p = makelongparameter (allWords, inst_bit_size - (start_bits + a->size),
- inst_bit_size - start_bits);
+ p = makelongparameter (cr16_allWords,
+ inst_bit_size - (start_bits + a->size),
+ inst_bit_size - start_bits);
a->rp = p.val;
break;

case arg_pr:
- p = makelongparameter (allWords, inst_bit_size - (start_bits + a->size),
- inst_bit_size - start_bits);
+ p = makelongparameter (cr16_allWords,
+ inst_bit_size - (start_bits + a->size),
+ inst_bit_size - start_bits);
a->pr = p.val;
break;

case arg_prp:
- p = makelongparameter (allWords, inst_bit_size - (start_bits + a->size),
- inst_bit_size - start_bits);
+ p = makelongparameter (cr16_allWords,
+ inst_bit_size - (start_bits + a->size),
+ inst_bit_size - start_bits);
a->prp = p.val;
break;

case arg_ic:
- p = makelongparameter (allWords, inst_bit_size - (start_bits + a->size),
- inst_bit_size - start_bits);
+ p = makelongparameter (cr16_allWords,
+ inst_bit_size - (start_bits + a->size),
+ inst_bit_size - start_bits);
a->constant = p.val;
break;

case arg_cc:
- p = makelongparameter (allWords, inst_bit_size - (start_bits + a->size),
- inst_bit_size - start_bits);
+ p = makelongparameter (cr16_allWords,
+ inst_bit_size - (start_bits + a->size),
+ inst_bit_size - start_bits);

a->cc = p.val;
break;
@@ -400,28 +404,30 @@ make_argument (argument * a, int start_b
if ((IS_INSN_MNEMONIC ("cbitb"))
|| (IS_INSN_MNEMONIC ("sbitb"))
|| (IS_INSN_MNEMONIC ("tbitb")))
- p = makelongparameter (allWords, 8, 9);
+ p = makelongparameter (cr16_allWords, 8, 9);
else
- p = makelongparameter (allWords, 9, 10);
+ p = makelongparameter (cr16_allWords, 9, 10);
a->i_r = p.val;
- p = makelongparameter (allWords, inst_bit_size - a->size, inst_bit_size);
+ p = makelongparameter (cr16_allWords,
+ inst_bit_size - a->size, inst_bit_size);
a->constant = p.val;
break;

case arg_idxrp:
- p = makelongparameter (allWords, start_bits + 12, start_bits + 13);
+ p = makelongparameter (cr16_allWords, start_bits + 12, start_bits + 13);
a->i_r = p.val;
- p = makelongparameter (allWords, start_bits + 13, start_bits + 16);
+ p = makelongparameter (cr16_allWords, start_bits + 13, start_bits + 16);
a->rp = p.val;
if (inst_bit_size > 32)
{
- p = makelongparameter (allWords, inst_bit_size - start_bits - 12,
+ p = makelongparameter (cr16_allWords, inst_bit_size - start_bits - 12,
inst_bit_size);
a->constant = ((p.val & 0xffff) | (p.val >> 8 & 0xf0000));
}
else if (instruction->size == 2)
{
- p = makelongparameter (allWords, inst_bit_size - 22, inst_bit_size);
+ p = makelongparameter (cr16_allWords, inst_bit_size - 22,
+ inst_bit_size);
a->constant = (p.val & 0xf) | (((p.val >>20) & 0x3) << 4)
| ((p.val >>14 & 0x3) << 6) | (((p.val >>7) & 0x1f) <<7);
}
@@ -431,41 +437,42 @@ make_argument (argument * a, int start_b
break;

case arg_rbase:
- p = makelongparameter (allWords, inst_bit_size, inst_bit_size);
+ p = makelongparameter (cr16_allWords, inst_bit_size, inst_bit_size);
a->constant = p.val;
- p = makelongparameter (allWords, inst_bit_size - (start_bits + 4),
+ p = makelongparameter (cr16_allWords, inst_bit_size - (start_bits + 4),
inst_bit_size - start_bits);
a->r = p.val;
break;

case arg_cr:
- p = makelongparameter (allWords, start_bits + 12, start_bits + 16);
+ p = makelongparameter (cr16_allWords, start_bits + 12, start_bits + 16);
a->r = p.val;
- p = makelongparameter (allWords, inst_bit_size - 16, inst_bit_size);
+ p = makelongparameter (cr16_allWords, inst_bit_size - 16, inst_bit_size);
a->constant = p.val;
break;

case arg_crp:
if (instruction->size == 1)
- p = makelongparameter (allWords, 12, 16);
+ p = makelongparameter (cr16_allWords, 12, 16);
else
- p = makelongparameter (allWords, start_bits + 12, start_bits + 16);
+ p = makelongparameter (cr16_allWords, start_bits + 12, start_bits + 16);
a->rp = p.val;

if (inst_bit_size > 32)
{
- p = makelongparameter (allWords, inst_bit_size - start_bits - 12,
+ p = makelongparameter (cr16_allWords, inst_bit_size - start_bits - 12,
inst_bit_size);
a->constant = ((p.val & 0xffff) | (p.val >> 8 & 0xf0000));
}
else if (instruction->size == 2)
{
- p = makelongparameter (allWords, inst_bit_size - 16, inst_bit_size);
+ p = makelongparameter (cr16_allWords, inst_bit_size - 16,
+ inst_bit_size);
a->constant = p.val;
}
else if (instruction->size == 1 && a->size != 0)
{
- p = makelongparameter (allWords, 4, 8);
+ p = makelongparameter (cr16_allWords, 4, 8);
if (IS_INSN_MNEMONIC ("loadw")
|| IS_INSN_MNEMONIC ("loadd")
|| IS_INSN_MNEMONIC ("storw")
@@ -489,36 +496,37 @@ make_argument (argument * a, int start_b
switch (a->size)
{
case 8 :
- p = makelongparameter (allWords, 0, start_bits);
+ p = makelongparameter (cr16_allWords, 0, start_bits);
a->constant = ((((p.val&0xf00)>>4)) | (p.val&0xf));
break;

case 24:
if (instruction->size == 3)
{
- p = makelongparameter (allWords, 16, inst_bit_size);
+ p = makelongparameter (cr16_allWords, 16, inst_bit_size);
a->constant = ((((p.val>>16)&0xf) << 20)
| (((p.val>>24)&0xf) << 16)
| (p.val & 0xffff));
}
else if (instruction->size == 2)
{
- p = makelongparameter (allWords, 8, inst_bit_size);
+ p = makelongparameter (cr16_allWords, 8, inst_bit_size);
a->constant = p.val;
}
break;

default:
- p = makelongparameter (allWords, inst_bit_size - (start_bits +
- a->size), inst_bit_size - start_bits);
+ p = makelongparameter (cr16_allWords,
+ inst_bit_size - (start_bits + a->size),
+ inst_bit_size - start_bits);
a->constant = p.val;
break;
}
}
else
{
- p = makelongparameter (allWords, inst_bit_size -
- (start_bits + a->size),
+ p = makelongparameter (cr16_allWords,
+ inst_bit_size - (start_bits + a->size),
inst_bit_size - start_bits);
a->constant = p.val;
}
@@ -734,13 +742,13 @@ print_arguments (ins *currentInsn, bfd_v

/* Build the instruction's arguments. */

-static void
+void
make_instruction (void)
{
int i;
unsigned int shift;

- for (i = 0; i < currInsn.nargs; i++)
+ for (i = 0; i < cr16_currInsn.nargs; i++)
{
argument a;

@@ -750,13 +758,13 @@ make_instruction (void)
shift = instruction->operands[i].shift;

make_argument (&a, shift);
- currInsn.arg[i] = a;
+ cr16_currInsn.arg[i] = a;
}

/* Calculate instruction size (in bytes). */
- currInsn.size = instruction->size + (size_changed ? 1 : 0);
+ cr16_currInsn.size = instruction->size + (size_changed ? 1 : 0);
/* Now in bits. */
- currInsn.size *= 2;
+ cr16_currInsn.size *= 2;
}

/* Retrieve a single word from a given memory address. */
@@ -785,10 +793,10 @@ get_words_at_PC (bfd_vma memaddr, struct
bfd_vma mem;

for (i = 0, mem = memaddr; i < 3; i++, mem += 2)
- words[i] = get_word_at_PC (mem, info);
+ cr16_words[i] = get_word_at_PC (mem, info);

- allWords =
- ((ULONGLONG) words[0] << 32) + ((unsigned long) words[1] << 16) + words[2];
+ cr16_allWords = ((ULONGLONG) cr16_words[0] << 32)
+ + ((unsigned long) cr16_words[1] << 16) + cr16_words[2];
}

/* Prints the instruction by calling print_arguments after proper matching. */
@@ -807,22 +815,22 @@ print_insn_cr16 (bfd_vma memaddr, struct
/* Find a matching opcode in table. */
is_decoded = match_opcode ();
/* If found, print the instruction's mnemonic and arguments. */
- if (is_decoded > 0 && (words[0] << 16 || words[1]) != 0)
+ if (is_decoded > 0 && (cr16_words[0] << 16 || cr16_words[1]) != 0)
{
if (strneq (instruction->mnemonic, "cinv", 4))
info->fprintf_func (info->stream,"%s", getcinvstring (instruction->mnemonic));
else
info->fprintf_func (info->stream, "%s", instruction->mnemonic);

- if (((currInsn.nargs = get_number_of_operands ()) != 0)
+ if (((cr16_currInsn.nargs = get_number_of_operands ()) != 0)
&& ! (IS_INSN_MNEMONIC ("b")))
info->fprintf_func (info->stream, "\t");
make_instruction ();
/* For push/pop/pushrtn with RA instructions. */
- if ((INST_HAS_REG_LIST) && ((words[0] >> 7) & 0x1))
- currInsn.nargs +=1;
- print_arguments (&currInsn, memaddr, info);
- return currInsn.size;
+ if ((INST_HAS_REG_LIST) && ((cr16_words[0] >> 7) & 0x1))
+ cr16_currInsn.nargs +=1;
+ print_arguments (&cr16_currInsn, memaddr, info);
+ return cr16_currInsn.size;
}

/* No match found. */
--- ./gdb_src.orig/bfd/config.bfd 2012-05-15 18:25:34.000000000 +0530
+++ ./gdb_src/bfd/config.bfd 2012-10-23 15:09:08.000000000 +0530
@@ -345,6 +345,11 @@ case "${targ}" in
targ_underscore=yes
;;

+ cr16*-*-uclinux*)
+ targ_defvec=bfd_elf32_cr16_vec
+ targ_underscore=yes
+ ;;
+
cr16c-*-elf*)
targ_defvec=bfd_elf32_cr16c_vec
targ_underscore=yes
--- ./gdb_src.orig/include/opcode/cr16.h 2010-04-15 15:56:09.000000000 +0530
+++ ./gdb_src/include/opcode/cr16.h 2012-12-28 12:49:50.000000000 +0530
@@ -435,4 +435,17 @@ extern const inst *instruction;
typedef long long int LONGLONG;
typedef unsigned long long ULONGLONG;

+/* Data types for opcode handling. */
+typedef unsigned long dwordU;
+typedef unsigned short wordU;
+
+/* Globals to store opcode data and build the instruction. */
+extern wordU cr16_words[3];
+extern ULONGLONG cr16_allWords;
+extern ins cr16_currInsn;
+
+/* Prototypes for function in cr16-dis.c. */
+void make_instruction (void);
+int match_opcode (void);
+
#endif /* _CR16_H_ */