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.

1 files changed, 67 insertions, 59 deletions

diff --git a/opcodes/cr16-dis.c b/opcodes/cr16-dis.c
index f299fef6c79..9fbdf00a5a9 100644
--- a/opcodes/cr16-dis.c
+++ b/opcodes/cr16-dis.c
@@ -1,5 +1,5 @@
 /* Disassembler code for CR16.
-   Copyright 2007, 2008, 2009, 2012  Free Software Foundation, Inc.
+   Copyright 2007, 2008, 2009, 2012, 2013  Free Software Foundation, Inc.
    Contributed by M R Swami Reddy (MR.Swami.Reddy@nsc.com).
 
    This file is part of GAS, GDB and the GNU binutils.
@@ -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_bits)
   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_bits)
       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_bits)
       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_bits)
 	  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_vma memaddr, struct disassemble_info *inf
 
 /* 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 disassemble_info *info)
   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 disassemble_info *info)
   /* 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.  */