Re: Saga of m68k PIC continues

[Peter Barada <pbarada@mail.wm.sps.mot.com>]

>> 1) Should general_src_operand accept the unspec symbol?
>
>Nope.

Ah well, I went and did it anyway, and now it generates code, stuff
that actually looks like its legal(not too efficent mind you).  I
successfully build all of glibc-2.2.5 for m68k using it.
Unfortunately without hardware I can't test it :-(

>
>> 2) If not, does anyone have an idea how I should get this instruction
>>    recognized? 
>
>You *may* want to wrap the unspec in a CONST.  That would 
>make the thing be recognized by general_operand.  But I
>can't tell if that's exactly right, since you've posted
>no code.

I pulled the code from i386.c, so it should do that.  Form a dump of
-fPIC code I see:

(insn 9 39 11 (set (reg/f:SI 0 %d0 [32])
        (const:SI (unspec:SI[ 
                    (symbol_ref:SI ("a"))
                ]  6))) 29 {*m68k.md:1007} (nil)
    (expr_list:REG_EQUIV (const:SI (unspec:SI[ 
                    (symbol_ref:SI ("a"))
                ]  6))
        (nil)))

so the unspec is wrapped in a const.

Here's everthing I've done to get to this point.  Its not pretty, and
nowehere near complete.  Any suggestions on which way to go from
here will be much apprecieated.

[pbarada: ~/work/cvs-wavemark/cross-linux-tools/gcc-3.2.1/gcc/config/m68k] > cvs diff -Nu m68k-protos.h m68k.h m68k.c m68k.md
Index: m68k-protos.h
===================================================================
RCS file: /usr/local/wavemark/cvs/archives/cross-linux-tools/gcc-3.2.1/gcc/config/m68k/m68k-protos.h,v
retrieving revision 1.1.1.1
diff -u -r1.1.1.1 m68k-protos.h
--- m68k-protos.h	2002/11/25 23:46:44	1.1.1.1
+++ m68k-protos.h	2002/12/12 00:05:15
@@ -1,5 +1,5 @@
 /* Definitions of target machine for GNU compiler.  Sun 68000/68020 version.
-   Copyright (C) 2000 Free Software Foundation, Inc.
+   Copyright (C) 2000, 2002 Free Software Foundation, Inc.
 
 This file is part of GNU CC.
 
@@ -47,6 +47,8 @@
 extern int strict_low_part_peephole_ok PARAMS ((enum machine_mode, rtx, rtx));
 
 /* Functions from m68k.c used in macros.  */
+extern int symbolic_reference_mentioned_p PARAMS ((rtx));
+extern int legitimate_pic_address_disp_p PARAMS ((rtx));
 extern int symbolic_operand PARAMS ((rtx, enum machine_mode));
 extern int const_int_cost PARAMS ((rtx));
 extern int standard_68881_constant_p PARAMS ((rtx));
Index: m68k.h
===================================================================
RCS file: /usr/local/wavemark/cvs/archives/cross-linux-tools/gcc-3.2.1/gcc/config/m68k/m68k.h,v
retrieving revision 1.1.1.1
diff -u -r1.1.1.1 m68k.h
--- m68k.h	2002/11/25 23:46:44	1.1.1.1
+++ m68k.h	2002/12/12 00:05:16
@@ -1,6 +1,6 @@
 /* Definitions of target machine for GNU compiler.
    Sun 68000/68020 version.
-   Copyright (C) 1987, 1988, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+   Copyright (C) 1987, 1988, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2002,
    2000, 2001, 2002 Free Software Foundation, Inc.
 
 This file is part of GNU CC.
@@ -280,7 +280,7 @@
 #define OVERRIDE_OPTIONS		\
 {					\
   override_options();			\
-  if (! TARGET_68020 && flag_pic == 2)	\
+  if (! (TARGET_68020 || TARGET_5200) && flag_pic == 2)	\
     error("-fPIC is not currently supported on the 68000 or 68010\n");	\
   if (TARGET_PCREL && flag_pic == 0)	\
     flag_pic = 1;			\
@@ -1305,6 +1305,16 @@
 #define PCREL_GENERAL_OPERAND_OK (TARGET_PCREL)
 #endif
 
+#if 1
+#define LEGITIMATE_PIC_OPERAND_P(X)		\
+  (! SYMBOLIC_CONST (X)				\
+   || legitimate_pic_address_disp_p (X))
+
+#define SYMBOLIC_CONST(X)	\
+  (GET_CODE (X) == SYMBOL_REF						\
+   || GET_CODE (X) == LABEL_REF						\
+   || (GET_CODE (X) == CONST && symbolic_reference_mentioned_p (X)))
+#else
 #define LEGITIMATE_PIC_OPERAND_P(X)	\
   ((! symbolic_operand (X, VOIDmode)				\
     && ! (GET_CODE (X) == CONST_DOUBLE && mem_for_const_double (X) != 0	\
@@ -1313,6 +1323,7 @@
 			       VOIDmode))) 				\
    || (GET_CODE (X) == SYMBOL_REF && SYMBOL_REF_FLAG (X))		\
    || PCREL_GENERAL_OPERAND_OK)
+#endif
 
 /* The macros REG_OK_FOR..._P assume that the arg is a REG rtx
    and check its validity for a certain class.
Index: m68k.c
===================================================================
RCS file: /usr/local/wavemark/cvs/archives/cross-linux-tools/gcc-3.2.1/gcc/config/m68k/m68k.c,v
retrieving revision 1.1.1.1
diff -u -r1.1.1.1 m68k.c
--- m68k.c	2002/11/25 23:46:44	1.1.1.1
+++ m68k.c	2002/12/12 00:05:16
@@ -1,5 +1,5 @@
 /* Subroutines for insn-output.c for Motorola 68000 family.
-   Copyright (C) 1987, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
+   Copyright (C) 1987, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
    Free Software Foundation, Inc.
 
 This file is part of GNU CC.
@@ -124,6 +124,12 @@
 
 struct gcc_target targetm = TARGET_INITIALIZER;
 \f
+#if 1
+/* Prefix built by ASM_GENERATE_INTERNAL_LABEL.  */
+static char internal_label_prefix[16];
+static int internal_label_prefix_len;
+#endif
+
 /* Sometimes certain combinations of command options do not make
    sense on a particular target machine.  You can define a macro
    `OVERRIDE_OPTIONS' to take account of this.  This macro, if
@@ -174,6 +180,15 @@
       else
 	m68k_align_funcs = i;
     }
+
+  /* Figure out what ASM_GENERATE_INTERNAL_LABEL builds as a prefix.  */
+  {
+    char *p;
+    ASM_GENERATE_INTERNAL_LABEL (internal_label_prefix, "LX", 0);
+    p = strchr (internal_label_prefix, 'X');
+    internal_label_prefix_len = p - internal_label_prefix;
+    *p = '\0';
+  }
 }
 \f
 /* This function generates the assembly code for function entry.
@@ -341,11 +356,22 @@
 
   if (flag_pic && current_function_uses_pic_offset_table)
     {
-      fprintf (stream, "\tmove.l #__GLOBAL_OFFSET_TABLE_, %s\n",
-	       reg_names[PIC_OFFSET_TABLE_REGNUM]);
-      fprintf (stream, "\tlea.l (pc,%s.l),%s\n",
-	       reg_names[PIC_OFFSET_TABLE_REGNUM],
-	       reg_names[PIC_OFFSET_TABLE_REGNUM]);
+      if (TARGET_5200)
+        {
+          asm_fprintf (stream, "\tmovel %0I_GLOBAL_OFFSET_TABLE_@GOTPC, %s\n",
+                       reg_names[PIC_OFFSET_TABLE_REGNUM]);
+          asm_fprintf (stream, "\tlea %Rpc@(-6,%s:l),%s\n",
+                       reg_names[PIC_OFFSET_TABLE_REGNUM],
+                       reg_names[PIC_OFFSET_TABLE_REGNUM]);
+        }
+      else
+        {
+          fprintf (stream, "\tmove.l #__GLOBAL_OFFSET_TABLE_, %s\n",
+                   reg_names[PIC_OFFSET_TABLE_REGNUM]);
+          fprintf (stream, "\tlea.l (pc,%s.l),%s\n",
+                   reg_names[PIC_OFFSET_TABLE_REGNUM],
+                   reg_names[PIC_OFFSET_TABLE_REGNUM]);
+        }
     }
 }
 
@@ -1901,6 +1927,7 @@
 /* Returns 1 if OP is either a symbol reference or a sum of a symbol
    reference and a constant.  */
 
+#if 1
 int
 symbolic_operand (op, mode)
      register rtx op;
@@ -1914,6 +1941,50 @@
 
     case CONST:
       op = XEXP (op, 0);
+      if (GET_CODE (op) == SYMBOL_REF
+	  || GET_CODE (op) == LABEL_REF
+	  || (GET_CODE (op) == UNSPEC
+	      && (XINT (op, 1) == 6
+		  || XINT (op, 1) == 7
+		  || XINT (op, 1) == 15)))
+	return 1;
+      if (GET_CODE (op) != PLUS
+	  || GET_CODE (XEXP (op, 1)) != CONST_INT)
+	return 0;
+
+      op = XEXP (op, 0);
+      if (GET_CODE (op) == SYMBOL_REF
+	  || GET_CODE (op) == LABEL_REF)
+	return 1;
+      /* Only @GOTOFF gets offsets.  */
+      if (GET_CODE (op) != UNSPEC
+	  || XINT (op, 1) != 7)
+	return 0;
+
+      op = XVECEXP (op, 0, 0);
+      if (GET_CODE (op) == SYMBOL_REF
+	  || GET_CODE (op) == LABEL_REF)
+	return 1;
+      return 0;
+
+    default:
+      return 0;
+    }
+}
+#else
+int
+symbolic_operand (op, mode)
+     register rtx op;
+     enum machine_mode mode ATTRIBUTE_UNUSED;
+{
+  switch (GET_CODE (op))
+    {
+    case SYMBOL_REF:
+    case LABEL_REF:
+      return 1;
+
+    case CONST:
+      op = XEXP (op, 0);
       return ((GET_CODE (XEXP (op, 0)) == SYMBOL_REF
 	       || GET_CODE (XEXP (op, 0)) == LABEL_REF)
 	      && GET_CODE (XEXP (op, 1)) == CONST_INT);
@@ -1928,6 +1999,7 @@
       return 0;
     }
 }
+#endif
 \f
 /* Check for sign_extend or zero_extend.  Used for bit-count operands.  */
 
@@ -1949,6 +2021,110 @@
 }
 
 \f
+
+#if 1
+/* Return true if OP is a symbolic operand that resolves locally.  */
+
+static int
+local_symbolic_operand (op, mode)
+     rtx op;
+     enum machine_mode mode ATTRIBUTE_UNUSED;
+{
+  if (GET_CODE (op) == LABEL_REF)
+    return 1;
+
+  if (GET_CODE (op) == CONST
+      && GET_CODE (XEXP (op, 0)) == PLUS
+      && GET_CODE (XEXP (XEXP (op, 0), 1)) == CONST_INT)
+    op = XEXP (XEXP (op, 0), 0);
+
+  if (GET_CODE (op) != SYMBOL_REF)
+    return 0;
+
+  /* These we've been told are local by varasm and encode_section_info
+     respectively.  */
+  if (CONSTANT_POOL_ADDRESS_P (op) || SYMBOL_REF_FLAG (op))
+    return 1;
+
+  /* There is, however, a not insubstantial body of code in the rest of
+     the compiler that assumes it can just stick the results of 
+     ASM_GENERATE_INTERNAL_LABEL in a symbol_ref and have done.  */
+  /* ??? This is a hack.  Should update the body of the compiler to
+     always create a DECL an invoke ENCODE_SECTION_INFO.  */
+  if (strncmp (XSTR (op, 0), internal_label_prefix,
+	       internal_label_prefix_len) == 0)
+    return 1;
+
+  return 0;
+}
+
+/* Determine if a given CONST RTX is a valid memory displacement
+   in PIC mode.  */
+
+int
+legitimate_pic_address_disp_p (disp)
+     register rtx disp;
+{
+  if (GET_CODE (disp) != CONST)
+    return 0;
+  disp = XEXP (disp, 0);
+
+  if (GET_CODE (disp) == PLUS)
+    {
+      if (GET_CODE (XEXP (disp, 1)) != CONST_INT)
+	return 0;
+      disp = XEXP (disp, 0);
+    }
+
+  if (GET_CODE (disp) != UNSPEC
+      || XVECLEN (disp, 0) != 1)
+    return 0;
+
+  /* Must be @GOT or @GOTOFF.  */
+  switch (XINT (disp, 1))
+    {
+    case 6: /* @GOT */
+      return GET_CODE (XVECEXP (disp, 0, 0)) == SYMBOL_REF;
+
+    case 7: /* @GOTOFF */
+      return local_symbolic_operand (XVECEXP (disp, 0, 0), Pmode);
+    }
+    
+  return 0;
+}
+
+/* Returns 1 if OP contains a symbol reference */
+
+int
+symbolic_reference_mentioned_p (op)
+     rtx op;
+{
+  register const char *fmt;
+  register int i;
+
+  if (GET_CODE (op) == SYMBOL_REF || GET_CODE (op) == LABEL_REF)
+    return 1;
+
+  fmt = GET_RTX_FORMAT (GET_CODE (op));
+  for (i = GET_RTX_LENGTH (GET_CODE (op)) - 1; i >= 0; i--)
+    {
+      if (fmt[i] == 'E')
+	{
+	  register int j;
+
+	  for (j = XVECLEN (op, i) - 1; j >= 0; j--)
+	    if (symbolic_reference_mentioned_p (XVECEXP (op, i, j)))
+	      return 1;
+	}
+
+      else if (fmt[i] == 'e' && symbolic_reference_mentioned_p (XEXP (op, i)))
+	return 1;
+    }
+
+  return 0;
+}
+
+#endif
 /* Legitimize PIC addresses.  If the address is already
    position-independent, we return ORIG.  Newly generated
    position-independent addresses go to REG.  If we need more
@@ -1989,6 +2165,122 @@
    That (in a nutshell) is how *all* symbol and label references are 
    handled.  */
 
+#if 1
+rtx
+legitimize_pic_address (orig, mode, reg)
+     rtx orig, reg;
+     enum machine_mode mode ATTRIBUTE_UNUSED;
+{
+  rtx addr = orig;
+  rtx pic_ref = addr;
+  rtx base;
+
+  /* First handle a simple SYMBOL_REF or LABEL_REF */
+  if (local_symbolic_operand(addr, Pmode))
+    {
+      if (reg == 0)
+	abort ();
+
+      if (TARGET_5200)
+        {
+          pic_ref = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), 7);
+          pic_ref = gen_rtx_CONST (Pmode, pic_ref);
+          /* Now move the symbol into a register(w/o using emit_move_insn) */
+          RTX_UNCHANGING_P (pic_ref) = 1;
+          emit_insn (gen_rtx_SET (Pmode, reg, pic_ref));
+          pic_ref = gen_rtx_MEM (Pmode,
+                                 gen_rtx_PLUS (Pmode,
+                                               pic_offset_table_rtx, reg));
+        }
+      else
+        {
+          pic_ref = gen_rtx_MEM (Pmode,
+                                 gen_rtx_PLUS (Pmode,
+                                               pic_offset_table_rtx, addr));
+        }
+      current_function_uses_pic_offset_table = 1;
+      RTX_UNCHANGING_P (pic_ref) = 1;
+      emit_move_insn (reg, pic_ref);
+      return reg;
+    }
+  else if (GET_CODE (addr) == SYMBOL_REF)
+    {
+      /* This symbol must be referenced via a load from the
+         Global Offset Table (@GOT).  */
+
+      current_function_uses_pic_offset_table = 1;
+      pic_ref = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), 6);
+      pic_ref = gen_rtx_CONST (Pmode, pic_ref);
+      pic_ref = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, pic_ref);
+      pic_ref = gen_rtx_MEM (Pmode, pic_ref);
+      RTX_UNCHANGING_P (pic_ref) = 1;
+      /*      set_mem_alias_set (new, ix86_GOT_alias_set ()); */
+
+      if (reg == 0)
+        reg = gen_reg_rtx (Pmode);
+      emit_move_insn (reg, pic_ref);
+      pic_ref = reg;
+    }
+  else 
+    {
+      if (GET_CODE (addr) == CONST)
+	{
+	  addr = XEXP (addr, 0);
+
+	  /* We must match stuff we generate before.  Assume the only
+	     unspecs that can get here are ours.  Not that we could do
+	     anything with them anyway...  */
+	  if (GET_CODE (addr) == UNSPEC
+	      || (GET_CODE (addr) == PLUS
+		  && GET_CODE (XEXP (addr, 0)) == UNSPEC))
+	    return addr;
+	  if (GET_CODE (addr) != PLUS)
+	    abort ();
+	}
+      if (GET_CODE (addr) == PLUS)
+	{
+	  rtx op0 = XEXP (addr, 0), op1 = XEXP (addr, 1);
+
+	  /* Check first to see if this is a constant offset from a @GOTOFF
+	     symbol reference.  */
+	  if (local_symbolic_operand (op0, Pmode)
+	      && GET_CODE (op1) == CONST_INT)
+	    {
+              current_function_uses_pic_offset_table = 1;
+              pic_ref = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, op0), 7);
+              pic_ref = gen_rtx_PLUS (Pmode, pic_ref, op1);
+              pic_ref = gen_rtx_CONST (Pmode, pic_ref);
+              pic_ref = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, pic_ref);
+              
+              if (reg != 0)
+                {
+                  emit_move_insn (reg, pic_ref);
+                  pic_ref = reg;
+                }
+	    }
+	  else
+	    {
+	      base = legitimize_pic_address (XEXP (addr, 0), mode, reg);
+	      pic_ref  = legitimize_pic_address (XEXP (addr, 1),
+					     mode, base == reg ? NULL_RTX : reg);
+
+	      if (GET_CODE (pic_ref) == CONST_INT)
+		pic_ref = plus_constant (base, INTVAL (pic_ref));
+	      else
+		{
+		  if (GET_CODE (pic_ref) == PLUS && CONSTANT_P (XEXP (pic_ref, 1)))
+		    {
+		      base = gen_rtx_PLUS (Pmode, base, XEXP (pic_ref, 0));
+		      pic_ref = XEXP (pic_ref, 1);
+		    }
+		  pic_ref = gen_rtx_PLUS (Pmode, base, pic_ref);
+		}
+	    }
+	}
+    }
+  return pic_ref;
+}
+#else
 rtx
 legitimize_pic_address (orig, mode, reg)
      rtx orig, reg;
@@ -2038,6 +2330,7 @@
     }
   return pic_ref;
 }
+#endif
 
 \f
 typedef enum { MOVL, SWAP, NEGW, NOTW, NOTB, MOVQ } CONST_METHOD;
@@ -3394,6 +3687,40 @@
 
    */
 
+static void output_pic_addr_const(file, op)
+     FILE *file;
+     rtx op;
+{
+  if (GET_CODE (op) == CONST)
+    op = XEXP(op, 0);
+  if (GET_CODE (op) == UNSPEC)
+    {
+       if (XVECLEN (op, 0) != 1)
+	abort ();
+       output_pic_addr_const (file, XVECEXP (op, 0, 0));
+       switch (XINT (op, 1))
+	{
+	case 6:
+	  fputs ("@GOT", file);
+	  break;
+	case 7:
+	  fputs ("@GOTOFF", file);
+	  break;
+	case 8:
+	  fputs ("@PLT", file);
+	  break;
+	case 15:
+	  fputs ("@GOTPCREL(%RIP)", file);
+	  break;
+	default:
+	  output_operand_lossage ("invalid UNSPEC as operand");
+	  break;
+	}
+    }
+  else
+    output_addr_const(file, op);    
+}
+
 void
 print_operand (file, op, letter)
      FILE *file;		/* file to write to */
@@ -3466,7 +3793,10 @@
       if (GET_CODE (op) != MEM || GET_CODE (XEXP (op, 0)) != SYMBOL_REF
           || !TARGET_PCREL) 
 	abort ();
-      output_addr_const (file, XEXP (op, 0));
+      if (flag_pic)
+        output_pic_addr_const (file, XEXP (op, 0));
+      else
+        output_addr_const (file, XEXP (op, 0));
     }
   else if (GET_CODE (op) == REG)
     {
@@ -3540,7 +3870,10 @@
 	  && (GET_CODE (op) == SYMBOL_REF || GET_CODE (op) == CONST))
 	print_operand_address (file, op);
       else
-	output_addr_const (file, op);
+        if (flag_pic)
+          output_pic_addr_const (file, op);
+        else
+          output_addr_const (file, op);
     }
 }
 
@@ -4065,6 +4398,11 @@
 	  || GET_CODE (XEXP (op, 0)) == LABEL_REF
 	  || GET_CODE (XEXP (op, 0)) == CONST))
     return 1;
+#if 1
+  /* Accept symols */
+  if (symbolic_operand(op, mode) || local_symbolic_operand(op, mode))
+    return 1;
+#endif
   return general_operand (op, mode);
 }
 
Index: m68k.md
===================================================================
RCS file: /usr/local/wavemark/cvs/archives/cross-linux-tools/gcc-3.2.1/gcc/config/m68k/m68k.md,v
retrieving revision 1.1.1.1
diff -u -r1.1.1.1 m68k.md
--- m68k.md	2002/11/25 23:46:44	1.1.1.1
+++ m68k.md	2002/12/12 00:05:16
@@ -273,6 +273,13 @@
 
 ;;- END FPA Explanation Section.
 
+/* Defien the constants being used by the unspec */
+(define_constants [
+  (UNSPEC_SIN		1)
+  (UNSPEC_COS		2)
+  (UNSPEC_GOT		3)
+  (UNSPEC_GOTOFF	4)
+])
 
 ;;- Some of these insn's are composites of several m68000 op codes.
 ;;- The assembler (or final @@??) insures that the appropriate one is
@@ -948,6 +955,29 @@
   ""
   "
 {
+#if 1
+    /* if PIC, push symbol into a register and then do the add */
+    if (flag_pic)
+      {
+        if (!reload_in_progress)
+          {
+            /* If the destination is a symbol,
+               push its address into a register */
+            if (symbolic_operand (operands[0], SImode))
+              operands[0] = force_reg (SImode, XEXP (operands[0], 0));
+            else if (GET_CODE (operands[0]) == MEM
+                     && symbolic_operand (XEXP (operands[0], 0), SImode))
+              operands[0] = gen_rtx (MEM, SImode,
+                                     force_reg (SImode, XEXP (operands[0], 0)));
+          }
+
+        if (symbolic_operand (operands[1], SImode))
+          {
+            rtx temp = reload_in_progress ? operands[0] : gen_reg_rtx (Pmode);
+            operands[1] = legitimize_pic_address (operands[1], SImode, temp);
+          }
+      }
+#else
   if (flag_pic && !TARGET_PCREL && symbolic_operand (operands[1], SImode))
     {
       /* The source is an address which requires PIC relocation.
@@ -968,6 +998,7 @@
 	operands[0] = gen_rtx (MEM, SImode,
 			       force_reg (SImode, XEXP (operands[0], 0)));
     }
+#endif
 }")
 
 ;; General case of fullword move.  The register constraints
@@ -8315,7 +8346,7 @@
 
 (define_insn "sinsf2"
   [(set (match_operand:SF 0 "nonimmediate_operand" "=f")
-	(unspec:SF [(match_operand:SF 1 "general_operand" "fm")] 1))]
+	(unspec:SF [(match_operand:SF 1 "general_operand" "fm")] UNSPEC_SIN))]
   "TARGET_68881 && flag_unsafe_math_optimizations"
   "*
 {
@@ -8327,7 +8358,7 @@
 
 (define_insn "sindf2"
   [(set (match_operand:DF 0 "nonimmediate_operand" "=f")
-	(unspec:DF [(match_operand:DF 1 "general_operand" "fm")] 1))]
+	(unspec:DF [(match_operand:DF 1 "general_operand" "fm")] UNSPEC_SIN))]
   "TARGET_68881 && flag_unsafe_math_optimizations"
   "*
 {
@@ -8339,13 +8370,13 @@
 
 (define_insn "sinxf2"
   [(set (match_operand:XF 0 "nonimmediate_operand" "=f")
-	(unspec:XF [(match_operand:XF 1 "nonimmediate_operand" "fm")] 1))]
+	(unspec:XF [(match_operand:XF 1 "nonimmediate_operand" "fm")] UNSPEC_SIN))]
   "TARGET_68881 && flag_unsafe_math_optimizations"
   "fsin%.x %1,%0")
 
 (define_insn "cossf2"
   [(set (match_operand:SF 0 "nonimmediate_operand" "=f")
-	(unspec:SF [(match_operand:SF 1 "general_operand" "fm")] 2))]
+	(unspec:SF [(match_operand:SF 1 "general_operand" "fm")] UNSPEC_COS))]
   "TARGET_68881 && flag_unsafe_math_optimizations"
   "*
 {
@@ -8357,7 +8388,7 @@
 
 (define_insn "cosdf2"
   [(set (match_operand:DF 0 "nonimmediate_operand" "=f")
-	(unspec:DF [(match_operand:DF 1 "general_operand" "fm")] 2))]
+	(unspec:DF [(match_operand:DF 1 "general_operand" "fm")] UNSPEC_COS))]
   "TARGET_68881 && flag_unsafe_math_optimizations"
   "*
 {
@@ -8369,7 +8400,7 @@
 
 (define_insn "cosxf2"
   [(set (match_operand:XF 0 "nonimmediate_operand" "=f")
-	(unspec:XF [(match_operand:XF 1 "nonimmediate_operand" "fm")] 2))]
+	(unspec:XF [(match_operand:XF 1 "nonimmediate_operand" "fm")] UNSPEC_COS))]
   "TARGET_68881 && flag_unsafe_math_optimizations"
   "fcos%.x %1,%0")
 
[pbarada: ~/work/cvs-wavemark/cross-linux-tools/gcc-3.2.1/gcc/config/m68k] > 

-- 
Peter Barada                                   Peter.Barada@motorola.com
Wizard                                         781-852-2768 (direct)
WaveMark Solutions(wholly owned by Motorola)   781-270-0193 (fax)