path: root/patches/gcc-4.4.3/atmel/0007-Add-support-for-devices-with-16-gp-registers.patch

From 564ff03f509767b2b1e34ad906d634e0b5c1fdcf Mon Sep 17 00:00:00 2001
From: Stephan Linz <linz@li-pro.net>
Date: Wed, 20 Apr 2011 22:29:45 +0200
Subject: [PATCH 07/10] Add support for devices with 16 gp registers

Add support for a bunch of new AVR devices, especially tiny devices
with 16 gp registers: attiny4, attiny5, attiny9, attiny10, attiny20,
attiny40

Compiler generates STS and LDS instructions for IO space less than
0x40 for attiny10, attiny20 and attiny40 families.

Original ATMEL patch from:
http://distribute.atmel.no/tools/opensource/avr-gcc/gcc-4.4.3/54-gcc-4.4.3-avrtiny10.patch
http://distribute.atmel.no/tools/opensource/avr-gcc/gcc-4.4.3/55-gcc-4.4.3-avrtiny10-bug-12510.patch

Signed-off-by: Stephan Linz <linz@li-pro.net>
---
 gcc/config/avr/avr.c          | 1370 +++++++++++++++++++++++++++++++----------
 gcc/config/avr/avr.h          |   55 ++-
 gcc/config/avr/avr.md         |    7 +-
 gcc/config/avr/libgcc-fixed.S |  203 ++++---
 gcc/config/avr/libgcc.S       |   44 ++-
 gcc/config/avr/predicates.md  |    9 +-
 gcc/config/avr/t-avr          |   12 +-
 7 files changed, 1274 insertions(+), 426 deletions(-)

diff --git a/gcc/config/avr/avr.c b/gcc/config/avr/avr.c
index b818c8b..422fad9 100644
--- a/gcc/config/avr/avr.c
+++ b/gcc/config/avr/avr.c
@@ -119,27 +119,28 @@ const struct base_arch_s *avr_current_arch;
 section *progmem_section;
 
 static const struct base_arch_s avr_arch_types[] = {
-  { 1, 0, 0, 0, 0, 0, 0, 0, 0, NULL },  /* Unknown device specified.  */
-  { 1, 0, 0, 0, 0, 0, 0, 0, 0, "__AVR_ARCH__=1"   },
-  { 0, 0, 0, 0, 0, 0, 0, 0, 0, "__AVR_ARCH__=2"   },
-  { 0, 0, 0, 1, 0, 0, 0, 0, 0, "__AVR_ARCH__=25"  },
-  { 0, 0, 1, 0, 0, 0, 0, 0, 0, "__AVR_ARCH__=3"   },
-  { 0, 0, 1, 0, 1, 0, 0, 0, 0, "__AVR_ARCH__=31"  },
-  { 0, 0, 1, 1, 0, 0, 0, 0, 0, "__AVR_ARCH__=35"  },
-  { 0, 1, 0, 1, 0, 0, 0, 0, 0, "__AVR_ARCH__=4"   },
-  { 0, 1, 1, 1, 0, 0, 0, 0, 0, "__AVR_ARCH__=5"   },
-  { 0, 1, 1, 1, 1, 1, 0, 0, 0, "__AVR_ARCH__=51"  },
-  { 0, 1, 1, 1, 1, 1, 1, 0, 0, "__AVR_ARCH__=6"   },
-  { 0, 1, 0, 1, 0, 0, 0, 1, 0, "__AVR_ARCH__=101" },
-  { 0, 1, 1, 1, 0, 0, 0, 1, 0, "__AVR_ARCH__=102" },
-  { 0, 1, 1, 1, 0, 0, 0, 1, 1, "__AVR_ARCH__=103" },
-  { 0, 1, 1, 1, 1, 1, 0, 1, 0, "__AVR_ARCH__=104" },
-  { 0, 1, 1, 1, 1, 1, 0, 1, 1, "__AVR_ARCH__=105" },
-  { 0, 1, 1, 1, 1, 1, 1, 1, 0, "__AVR_ARCH__=106" },
-  { 0, 1, 1, 1, 1, 1, 1, 1, 1, "__AVR_ARCH__=107" }
+  { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL },  /* Unknown device specified.  */
+  { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "__AVR_ARCH__=1"   },
+  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "__AVR_ARCH__=2"   },
+  { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, "__AVR_ARCH__=25"  },
+  { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, "__AVR_ARCH__=3"   },
+  { 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, "__AVR_ARCH__=31"  },
+  { 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, "__AVR_ARCH__=35"  },
+  { 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, "__AVR_ARCH__=4"   },
+  { 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, "__AVR_ARCH__=5"   },
+  { 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, "__AVR_ARCH__=51"  },
+  { 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, "__AVR_ARCH__=6"   },
+  { 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, "__AVR_ARCH__=101" },
+  { 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, "__AVR_ARCH__=102" },
+  { 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, "__AVR_ARCH__=103" },
+  { 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, "__AVR_ARCH__=104" },
+  { 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, "__AVR_ARCH__=105" },
+  { 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, "__AVR_ARCH__=106" },
+  { 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, "__AVR_ARCH__=107" },
+  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "__AVR_ARCH__=201" }
 };
 
-/* These names are used as the index into the avr_arch_types[] table 
+/* These names are used as the index into the avr_arch_types[] table
    above.  */
 
 enum avr_arch
@@ -161,7 +162,8 @@ enum avr_arch
   ARCH_AVRXMEGA4,
   ARCH_AVRXMEGA5,
   ARCH_AVRXMEGA6,
-  ARCH_AVRXMEGA7
+  ARCH_AVRXMEGA7,
+  ARCH_AVRTINY10
 };
 
 struct mcu_type_s {
@@ -394,6 +396,14 @@ static const struct mcu_type_s avr_mcu_types[] = {
   { "avrxmega7",    ARCH_AVRXMEGA7, NULL },
   { "atxmega128a1", ARCH_AVRXMEGA7, "__AVR_ATxmega128A1__" },
   { "atxmega128a1u",ARCH_AVRXMEGA7, "__AVR_ATxmega128A1U__" },
+	/* tiny10 family */
+  { "avrtiny10",   ARCH_AVRTINY10, NULL },
+  { "attiny4",     ARCH_AVRTINY10, "__AVR_ATtiny4__" },
+  { "attiny5",     ARCH_AVRTINY10, "__AVR_ATtiny5__" },
+  { "attiny9",     ARCH_AVRTINY10, "__AVR_ATtiny9__" },
+  { "attiny10",    ARCH_AVRTINY10, "__AVR_ATtiny10__" },
+  { "attiny20",    ARCH_AVRTINY10, "__AVR_ATtiny20__" },
+  { "attiny40",    ARCH_AVRTINY10, "__AVR_ATtiny40__" },
     /* Assembler only.  */
   { "avr1",         ARCH_AVR1, NULL },
   { "at90s1200",    ARCH_AVR1, "__AVR_AT90S1200__" },
@@ -510,10 +520,8 @@ avr_override_options (void)
       inform (input_location, "use the -fno-jump-tables switch instead");
       warned_no_tablejump_deprecated = true;
     }
-
-  tmp_reg_rtx  = gen_rtx_REG (QImode, TMP_REGNO);
-  zero_reg_rtx = gen_rtx_REG (QImode, ZERO_REGNO);
-
+	 tmp_reg_rtx  = gen_rtx_REG (QImode, AVR_TINY ? TMP_REGNO_AVRTINY10 : TMP_REGNO);
+	 zero_reg_rtx = gen_rtx_REG (QImode, AVR_TINY ? ZERO_REGNO_AVRTINY10 : ZERO_REGNO);
   init_machine_status = avr_init_machine_status;
 }
 
@@ -1863,7 +1871,7 @@ avr_simplify_comparison_p (enum machine_mode mode, RTX_CODE op, rtx x)
 int
 function_arg_regno_p(int r)
 {
-  return (r >= 8 && r <= 25);
+  return (AVR_TINY ? r >= 20 && r <= 25 : r >= 8 && r <= 25);
 }
 
 /* Initializing the variable cum for the state at the beginning
@@ -1873,7 +1881,11 @@ void
 init_cumulative_args (CUMULATIVE_ARGS *cum, tree fntype, rtx libname,
 		      tree fndecl ATTRIBUTE_UNUSED)
 {
+  if (AVR_TINY)
+	  cum->nregs = 6;
+  else
   cum->nregs = 18;
+
   cum->regno = FIRST_CUM_REG;
   if (!libname && fntype)
     {
@@ -1897,9 +1909,8 @@ avr_num_arg_regs (enum machine_mode mode, tree type)
   else
     size = GET_MODE_SIZE (mode);
 
-  /* Align all function arguments to start in even-numbered registers.
+  /* if not AVR_TINY, Align all function arguments to start in even-numbered registers.
      Odd-sized arguments leave holes above them.  */
-
   return (size + 1) & ~1;
 }
 
@@ -2231,9 +2242,19 @@ out_movqi_r_mr (rtx insn, rtx op[], int *l)
 	    fatal_insn ("incorrect insn:",insn);
 
 	  if (disp <= 63 + MAX_LD_OFFSET (GET_MODE (src)))
-	    return *l = 3, (AS2 (adiw,r28,%o1-63) CR_TAB
-			    AS2 (ldd,%0,Y+63)     CR_TAB
-			    AS2 (sbiw,r28,%o1-63));
+	    return *l = 3, AVR_TINY ? (AS2 (subi,r28,lo8(-(%o1-63))) CR_TAB
+				          AS2 (sbci,r29,hi8(-(%o1-63))) CR_TAB
+						  AS2 (subi,r28,lo8(-63))       CR_TAB
+				          AS2 (sbci,r29,hi8(-63))       CR_TAB
+			              AS2 (ld,%0,Y)                 CR_TAB
+						  AS2 (subi,r28,lo8(63))       CR_TAB
+				          AS2 (sbci,r29,hi8(63))       CR_TAB
+						  AS2 (subi,r28,lo8(%o1-63)) CR_TAB
+				          AS2 (sbci,r29,hi8(%o1-63)))
+		                   : (AS2 (adiw,r28,%o1-63) CR_TAB
+			              AS2 (ldd,%0,Y+63)     CR_TAB
+			              AS2 (sbiw,r28,%o1-63));
+
 
 	  return *l = 5, (AS2 (subi,r28,lo8(-%o1)) CR_TAB
 			  AS2 (sbci,r29,hi8(-%o1)) CR_TAB
@@ -2247,15 +2268,38 @@ out_movqi_r_mr (rtx insn, rtx op[], int *l)
 	     it but I have this situation with extremal optimizing options.  */
 	  if (reg_overlap_mentioned_p (dest, XEXP (x,0))
 	      || reg_unused_after (insn, XEXP (x,0)))
-	    return *l = 2, (AS2 (adiw,r26,%o1) CR_TAB
-			    AS2 (ld,%0,X));
-
-	  return *l = 3, (AS2 (adiw,r26,%o1) CR_TAB
-			  AS2 (ld,%0,X)      CR_TAB
-			  AS2 (sbiw,r26,%o1));
+	    return *l = 2, AVR_TINY ? (AS2 (subi,r26,lo8(-(%o1))) CR_TAB
+						  AS2 (sbci,r27,hi8(-(%o1))) CR_TAB
+						  AS2 (ld,%0,X))
+						   : (AS2 (adiw,r26,%o1) CR_TAB
+			              AS2 (ld,%0,X));
+
+	    return *l = 3, AVR_TINY ? (AS2 (subi,r26,lo8(-(%o1))) CR_TAB
+						  AS2 (sbci,r27,hi8(-(%o1))) CR_TAB
+						  AS2 (ld,%0,X) CR_TAB
+						  AS2 (subi,r26,lo8(%o1)) CR_TAB
+				          AS2 (sbci,r27,hi8(%o1)))
+						   : (AS2 (adiw,r26,%o1) CR_TAB
+			              AS2 (ld,%0,X)      CR_TAB
+			              AS2 (sbiw,r26,%o1));
 	}
+
       *l = 1;
-      return AS2 (ldd,%0,%1);
+	  op[2] = XEXP(x, 0);
+	  if(REGNO(op[2]) == REG_Y)
+			  return AVR_TINY ? ( AS2 (subi,%A2,lo8(-(%o1))) CR_TAB
+						AS2 (sbci,%B2,hi8(-(%o1))) CR_TAB
+						AS2 (ld,%0,Y)              CR_TAB
+			            AS2 (subi,%A2,lo8(%o1)) CR_TAB
+						AS2 (sbci,%B2,hi8(%o1)))
+						 :   AS2 (ldd,%0,%1);
+	  if(REGNO(op[2]) == REG_Z)
+			  return AVR_TINY ? ( AS2 (subi,%A2,lo8(-(%o1))) CR_TAB
+						AS2 (sbci,%B2,hi8(-(%o1))) CR_TAB
+						AS2 (ld,%0,Z)              CR_TAB
+			            AS2 (subi,%A2,lo8(%o1)) CR_TAB
+						AS2 (sbci,%B2,hi8(%o1)))
+						 :   AS2 (ldd,%0,%1);
     }
   *l = 1;
   return AS2 (ld,%0,%1);
@@ -2295,15 +2339,35 @@ out_movhi_r_mr (rtx insn, rtx op[], int *l)
 		      AS2 (ld,%B0,X));
 	    }
 	  *l  = 3;
-	  return (AS2 (ld,%A0,X+) CR_TAB
-		  AS2 (ld,%B0,X) CR_TAB
-		  AS2 (sbiw,r26,1));
+	  return AVR_TINY ? (AS2 (ld,%A0,X+) CR_TAB
+				AS2 (ld,%B0,X)  CR_TAB
+				AS2 (subi,r26,lo8(1))          CR_TAB
+				AS2 (sbci,r27,hi8(1)))
+		         : (AS2 (ld,%A0,X+) CR_TAB
+		        AS2 (ld,%B0,X) CR_TAB
+		        AS2 (sbiw,r26,1));
         }
       else                      /* (R)  */
 	{
 	  *l = 2;
-	  return (AS2 (ld,%A0,%1)    CR_TAB
-		  AS2 (ldd,%B0,%1+1));
+	  if(reg_base == REG_Y)
+	  return AVR_TINY ? (AS2 (ld,%A0,%1) CR_TAB
+				AS2 (subi,r28,lo8((-1))) CR_TAB
+				AS2 (sbci,r29,hi8((-1))) CR_TAB
+		        AS2 (ld,%B0,%1) CR_TAB
+				AS2 (subi,r28,lo8(1)) CR_TAB
+				AS2 (sbci,r29,hi8(1)))
+		         : (AS2 (ld,%A0,%1) CR_TAB
+				AS2 (ldd,%B0,%1+1));
+	  if(reg_base == REG_Z)
+	  return AVR_TINY ? (AS2 (ld,%A0,%1) CR_TAB
+				AS2 (subi,r30,lo8((-1))) CR_TAB
+				AS2 (sbci,r31,hi8((-1))) CR_TAB
+		        AS2 (ld,%B0,%1) CR_TAB
+				AS2 (subi,r30,lo8(1)) CR_TAB
+				AS2 (sbci,r31,hi8(1)))
+		         : (AS2 (ld,%A0,%1) CR_TAB
+		        AS2 (ldd,%B0,%1+1));
 	}
     }
   else if (GET_CODE (base) == PLUS) /* (R + i) */
@@ -2317,17 +2381,35 @@ out_movhi_r_mr (rtx insn, rtx op[], int *l)
 	    fatal_insn ("incorrect insn:",insn);
 	  
 	  if (disp <= 63 + MAX_LD_OFFSET (GET_MODE (src)))
-	    return *l = 4, (AS2 (adiw,r28,%o1-62) CR_TAB
-			    AS2 (ldd,%A0,Y+62)    CR_TAB
-			    AS2 (ldd,%B0,Y+63)    CR_TAB
-			    AS2 (sbiw,r28,%o1-62));
-
-	  return *l = 6, (AS2 (subi,r28,lo8(-%o1)) CR_TAB
-			  AS2 (sbci,r29,hi8(-%o1)) CR_TAB
-			  AS2 (ld,%A0,Y)           CR_TAB
-			  AS2 (ldd,%B0,Y+1)        CR_TAB
-			  AS2 (subi,r28,lo8(%o1))  CR_TAB
-			  AS2 (sbci,r29,hi8(%o1)));
+	    return *l = 4, AVR_TINY ? (AS2 (subi,r28,lo8(-(%o1-62))) CR_TAB
+				          AS2 (sbci,r29,hi8(-(%o1-62))) CR_TAB
+						  AS2 (subi,r28,lo8(-62))       CR_TAB
+				          AS2 (sbci,r29,hi8(-62))       CR_TAB
+			              AS2 (ld,%A0,Y+)                CR_TAB
+			              AS2 (ld,%B0,Y)                CR_TAB
+						  AS2 (subi,r28,lo8(63))       CR_TAB
+				          AS2 (sbci,r29,hi8(63))       CR_TAB
+						  AS2 (subi,r28,lo8(%o1-62)) CR_TAB
+				          AS2 (sbci,r29,hi8(%o1-62)))
+			               : (AS2 (adiw,r28,%o1-62) CR_TAB
+			              AS2 (ldd,%A0,Y+62)    CR_TAB
+			              AS2 (ldd,%B0,Y+63)    CR_TAB
+			              AS2 (sbiw,r28,%o1-62));
+
+	  return *l = 6, AVR_TINY ? (AS2 (subi,r28,lo8(-%o1)) CR_TAB
+						AS2 (sbci,r29,hi8(-%o1)) CR_TAB
+						AS2 (ld,%A0,Y+)          CR_TAB
+						AS2 (ld,%B0,Y)           CR_TAB
+						AS2 (subi,r28,lo8(1))   CR_TAB
+						AS2 (sbci,r29,hi8(1))   CR_TAB
+					AS2 (subi,r28,lo8(%o1))  CR_TAB
+						AS2 (sbci,r29,hi8(%o1)))
+						 : (AS2 (subi,r28,lo8(-%o1)) CR_TAB
+			            AS2 (sbci,r29,hi8(-%o1)) CR_TAB
+			            AS2 (ld,%A0,Y)           CR_TAB
+			            AS2 (ldd,%B0,Y+1)        CR_TAB
+			            AS2 (subi,r28,lo8(%o1))  CR_TAB
+			            AS2 (sbci,r29,hi8(%o1)));
 	}
       if (reg_base == REG_X)
 	{
@@ -2337,28 +2419,79 @@ out_movhi_r_mr (rtx insn, rtx op[], int *l)
 	  
 	  *l = 4;
 	  if (reg_base == reg_dest)
-	    return (AS2 (adiw,r26,%o1)      CR_TAB
-		    AS2 (ld,__tmp_reg__,X+) CR_TAB
-		    AS2 (ld,%B0,X)          CR_TAB
-		    AS2 (mov,%A0,__tmp_reg__));
-
-	  return (AS2 (adiw,r26,%o1) CR_TAB
-		  AS2 (ld,%A0,X+)    CR_TAB
-		  AS2 (ld,%B0,X)     CR_TAB
-		  AS2 (sbiw,r26,%o1+1));
+	    return AVR_TINY ? (AS2 (subi,r26,lo8(-%o1))      CR_TAB
+				  AS2 (sbci,r27,hi8(-%o1))      CR_TAB
+		          AS2 (ld,__tmp_reg__,X+)       CR_TAB
+		          AS2 (ld,%B0,X)                CR_TAB
+		          AS2 (mov,%A0,__tmp_reg__))
+			       : (AS2 (adiw,r26,%o1)      CR_TAB
+		          AS2 (ld,__tmp_reg__,X+) CR_TAB
+		          AS2 (ld,%B0,X)          CR_TAB
+		          AS2 (mov,%A0,__tmp_reg__));
+
+	    return AVR_TINY ? (AS2 (subi,r26,lo8(-%o1))      CR_TAB
+		          AS2 (sbci,r27,hi8(-%o1))      CR_TAB
+		          AS2 (ld,%A0,X+)			     CR_TAB
+		          AS2 (ld,%B0,X)                CR_TAB
+				  AS2 (subi,r26,lo8(%o1+1))     CR_TAB
+				  AS2 (sbci,r27,hi8(%o1+1)))
+		           : (AS2 (adiw,r26,%o1) CR_TAB
+		          AS2 (ld,%A0,X+)    CR_TAB
+		          AS2 (ld,%B0,X)     CR_TAB
+		          AS2 (sbiw,r26,%o1+1));
 	}
 
       if (reg_base == reg_dest)
 	{
 	  *l = 3;
-	  return (AS2 (ldd,__tmp_reg__,%A1) CR_TAB
-		  AS2 (ldd,%B0,%B1)         CR_TAB
-		  AS2 (mov,%A0,__tmp_reg__));
+	  op[2] = XEXP(base, 0);
+
+	  if(REGNO(op[2]) == REG_Y)
+			  return AVR_TINY ? ( AS2 (subi,%A2,lo8(-(%o1))) CR_TAB
+						AS2 (sbci,%B2,hi8(-(%o1))) CR_TAB
+						AS2 (ld,__tmp_reg__,Y+)     CR_TAB
+		                AS2 (ld,%B0,Y)         CR_TAB
+						AS2 (subi,%A2,lo8(%o1+1)) CR_TAB
+						AS2 (subi,%B2,hi8(%o1+1)) CR_TAB
+						AS2 (mov,%A0,__tmp_reg__))
+				         :  (AS2 (ldd,__tmp_reg__,%A1) CR_TAB
+		                AS2 (ldd,%B0,%B1)         CR_TAB
+		                AS2 (mov,%A0,__tmp_reg__));
+	  if(REGNO(op[2]) == REG_Z)
+			  return AVR_TINY ? ( AS2 (subi,%A2,lo8(-(%o1))) CR_TAB
+						AS2 (sbci,%B2,hi8(-(%o1))) CR_TAB
+						AS2 (ld,__tmp_reg__,Z+)     CR_TAB
+		                AS2 (ld,%B0,Z)         CR_TAB
+						AS2 (subi,%A2,lo8(%o1+1)) CR_TAB
+						AS2 (subi,%B2,hi8(%o1+1)) CR_TAB
+						AS2 (mov,%A0,__tmp_reg__))
+				         :  (AS2 (ldd,__tmp_reg__,%A1) CR_TAB
+		                AS2 (ldd,%B0,%B1)         CR_TAB
+		                AS2 (mov,%A0,__tmp_reg__));
 	}
-      
       *l = 2;
-      return (AS2 (ldd,%A0,%A1) CR_TAB
-	      AS2 (ldd,%B0,%B1));
+
+	  op[2] = XEXP(base, 0);
+
+	  if(REGNO(op[2]) == REG_Y)
+			  return AVR_TINY ? ( AS2 (subi,%A2,lo8(-(%o1))) CR_TAB
+						AS2 (sbci,%B2,hi8(-(%o1))) CR_TAB
+						AS2 (ld,%A0,Y+)             CR_TAB
+		                AS2 (ld,%B0,Y)               CR_TAB
+						AS2 (subi,%A2,lo8(%o1+1)) CR_TAB
+						AS2 (subi,%B2,hi8(%o1+1)))
+				         :  (AS2 (ldd,%A0,%A1) CR_TAB
+		                AS2 (ldd,%B0,%B1));
+	  if(REGNO(op[2]) == REG_Z)
+			  return AVR_TINY ? ( AS2 (subi,%A2,lo8(-(%o1))) CR_TAB
+						AS2 (sbci,%B2,hi8(-(%o1))) CR_TAB
+						AS2 (ld,%A0,Z+)             CR_TAB
+		                AS2 (ld,%B0,Z)              CR_TAB
+						AS2 (subi,%A2,lo8(%o1+1)) CR_TAB
+						AS2 (subi,%B2,hi8(%o1+1)))
+				         :  (AS2 (ldd,%A0,%A1) CR_TAB
+	                    AS2 (ldd,%B0,%B1));
+
     }
   else if (GET_CODE (base) == PRE_DEC) /* (--R) */
     {
@@ -2370,17 +2503,32 @@ out_movhi_r_mr (rtx insn, rtx op[], int *l)
           if (REGNO (XEXP (base, 0)) == REG_X)
             {
               *l = 4;
-              return (AS2 (sbiw,r26,2)  CR_TAB
-                      AS2 (ld,%A0,X+)   CR_TAB
-                      AS2 (ld,%B0,X)    CR_TAB
-                      AS2 (sbiw,r26,1));
+              return AVR_TINY ? (AS2 (subi,r26,lo8(2))  CR_TAB
+					    AS2 (sbci,r27,hi8(2))   CR_TAB
+                        AS2 (ld,%A0,X+)            CR_TAB
+                        AS2 (ld,%B0,X)             CR_TAB
+						AS2 (subi,r26,lo8(1))  CR_TAB
+						AS2 (sbci,r27,hi8(1)))
+				         : (AS2 (sbiw,r26,2)  CR_TAB
+                        AS2 (ld,%A0,X+)   CR_TAB
+                        AS2 (ld,%B0,X)    CR_TAB
+                        AS2 (sbiw,r26,1));
             }
           else
             {
               *l = 3;
-              return (AS2 (sbiw,%r1,2)   CR_TAB
-                      AS2 (ld,%A0,%p1)  CR_TAB
-                      AS2 (ldd,%B0,%p1+1));
+			  //FIXME:check the code once again for AVR_TINY
+              return AVR_TINY ? (AS2 (subi,%A1,lo8(3))  CR_TAB
+					    AS2 (sbci,%B1,hi8(3))  CR_TAB
+                        AS2 (ld,%A0,%p1)       CR_TAB
+						AS2 (subi,%A1,lo8(-1)) CR_TAB
+						AS2 (sbci,%B1,hi8(-1)) CR_TAB
+                        AS2 (ld,%B0,%p1)       CR_TAB
+						AS2 (subi,%A1,lo8(1)) CR_TAB
+						AS2 (sbci,%B1,hi8(1)))
+				         : (AS2 (sbiw,%r1,2)   CR_TAB
+                        AS2 (ld,%A0,%p1)  CR_TAB
+                        AS2 (ldd,%B0,%p1+1));
             }
         }
 
@@ -2434,13 +2582,23 @@ out_movsi_r_mr (rtx insn, rtx op[], int *l)
         {
           if (reg_dest == REG_X)
 	    /* "ld r26,-X" is undefined */
-	    return *l=7, (AS2 (adiw,r26,3)        CR_TAB
-			  AS2 (ld,r29,X)          CR_TAB
-			  AS2 (ld,r28,-X)         CR_TAB
-			  AS2 (ld,__tmp_reg__,-X) CR_TAB
-			  AS2 (sbiw,r26,1)        CR_TAB
-			  AS2 (ld,r26,X)          CR_TAB
-			  AS2 (mov,r27,__tmp_reg__));
+	    return *l=7, AVR_TINY ? (AS2 (subi,r26,lo8(-3))  CR_TAB
+						AS2 (sbci,r27,hi8(-3))  CR_TAB
+			            AS2 (ld,r29,X)          CR_TAB
+			            AS2 (ld,r28,-X)         CR_TAB
+			            AS2 (ld,__tmp_reg__,-X) CR_TAB
+			            AS2 (subi,r26,lo8(1))   CR_TAB
+			            AS2 (sbci,r27,hi8(1))   CR_TAB
+			            AS2 (ld,r26,X)          CR_TAB
+			            AS2 (mov,r27,__tmp_reg__))
+			             : (AS2 (adiw,r26,3)        CR_TAB
+			            AS2 (ld,r29,X)          CR_TAB
+			            AS2 (ld,r28,-X)         CR_TAB
+			            AS2 (ld,__tmp_reg__,-X) CR_TAB
+			            AS2 (sbiw,r26,1)        CR_TAB
+			            AS2 (ld,r26,X)          CR_TAB
+			            AS2 (mov,r27,__tmp_reg__));
+
           else if (reg_dest == REG_X - 2)
             return *l=5, (AS2 (ld,%A0,X+)  CR_TAB
                           AS2 (ld,%B0,X+) CR_TAB
@@ -2453,33 +2611,114 @@ out_movsi_r_mr (rtx insn, rtx op[], int *l)
                            AS2 (ld,%C0,X+) CR_TAB
                            AS2 (ld,%D0,X));
           else
-            return  *l=5, (AS2 (ld,%A0,X+)  CR_TAB
-                           AS2 (ld,%B0,X+) CR_TAB
-                           AS2 (ld,%C0,X+) CR_TAB
-                           AS2 (ld,%D0,X)  CR_TAB
-                           AS2 (sbiw,r26,3));
+            return  *l=5, AVR_TINY ? (AS2 (ld,%A0,X+) CR_TAB
+                             AS2 (ld,%B0,X+) CR_TAB
+                             AS2 (ld,%C0,X+) CR_TAB
+                             AS2 (ld,%D0,X)  CR_TAB
+                             AS2 (subi,r26,lo8(3)) CR_TAB
+                             AS2 (sbci,r27,hi8(3)))
+					          : (AS2 (ld,%A0,X+) CR_TAB
+                             AS2 (ld,%B0,X+) CR_TAB
+                             AS2 (ld,%C0,X+) CR_TAB
+                             AS2 (ld,%D0,X)  CR_TAB
+                             AS2 (sbiw,r26,3));
         }
       else
         {
           if (reg_dest == reg_base)
-            return *l=5, (AS2 (ldd,%D0,%1+3) CR_TAB
-                          AS2 (ldd,%C0,%1+2) CR_TAB
-                          AS2 (ldd,__tmp_reg__,%1+1)  CR_TAB
-                          AS2 (ld,%A0,%1)  CR_TAB
-                          AS2 (mov,%B0,__tmp_reg__));
+		  {
+			  if(reg_base == REG_Y)
+            return *l=5, AVR_TINY ? (AS2 (subi,r28,lo8(-3)) CR_TAB
+							AS2 (sbci,r29,hi8(-3)) CR_TAB
+				            AS2 (ld,%D0,Y)        CR_TAB
+                            AS2 (ld,%C0,-Y)        CR_TAB
+                            AS2 (subi,r28,lo8(1)) CR_TAB
+                            AS2 (sbci,r29,hi8(1)) CR_TAB
+                            AS2 (ld,__tmp_reg__,%1)  CR_TAB
+                            AS2 (subi,r28,lo8(1)) CR_TAB
+                            AS2 (sbci,r29,hi8(1)) CR_TAB
+                            AS2 (ld,%A0,%1)  CR_TAB
+                            AS2 (mov,%B0,__tmp_reg__))
+				             : (AS2 (ldd,%D0,%1+3) CR_TAB
+                            AS2 (ldd,%C0,%1+2) CR_TAB
+                            AS2 (ldd,__tmp_reg__,%1+1)  CR_TAB
+                            AS2 (ld,%A0,%1)  CR_TAB
+                            AS2 (mov,%B0,__tmp_reg__));
+			  if(reg_base == REG_Z)
+            return *l=5, AVR_TINY ? (AS2 (subi,r30,lo8(-3)) CR_TAB
+							AS2 (sbci,r31,hi8(-3)) CR_TAB
+				            AS2 (ld,%D0,Z)        CR_TAB
+                            AS2 (ld,%C0,-Z)        CR_TAB
+                            AS2 (subi,r30,lo8(1)) CR_TAB
+                            AS2 (sbci,r31,hi8(1)) CR_TAB
+                            AS2 (ld,__tmp_reg__,%1)  CR_TAB
+                            AS2 (subi,r30,lo8(1)) CR_TAB
+                            AS2 (sbci,r31,hi8(1)) CR_TAB
+                            AS2 (ld,%A0,%1)  CR_TAB
+                            AS2 (mov,%B0,__tmp_reg__))
+				             : (AS2 (ldd,%D0,%1+3) CR_TAB
+                            AS2 (ldd,%C0,%1+2) CR_TAB
+                            AS2 (ldd,__tmp_reg__,%1+1)  CR_TAB
+                            AS2 (ld,%A0,%1)  CR_TAB
+                            AS2 (mov,%B0,__tmp_reg__));
+		  }
+
           else if (reg_base == reg_dest + 2)
-            return *l=5, (AS2 (ld ,%A0,%1)    CR_TAB
-                          AS2 (ldd,%B0,%1+1) CR_TAB
-                          AS2 (ldd,__tmp_reg__,%1+2)  CR_TAB
-                          AS2 (ldd,%D0,%1+3) CR_TAB
-                          AS2 (mov,%C0,__tmp_reg__));
+		  {
+			  if(reg_base == REG_Y)
+            return *l=5, AVR_TINY ? (AS2 (ld ,%A0,Y+)       CR_TAB
+                            AS2 (ld,%B0,Y+) CR_TAB
+                            AS2 (ld,__tmp_reg__,Y+) CR_TAB
+                            AS2 (ld,%D0,Y) CR_TAB
+                            AS2 (subi,r28,lo8(3)) CR_TAB
+                            AS2 (sbci,r29,hi8(3)) CR_TAB
+                            AS2 (mov,%C0,__tmp_reg__))
+				             : (AS2 (ld ,%A0,%1)    CR_TAB
+                            AS2 (ldd,%B0,%1+1) CR_TAB
+                            AS2 (ldd,__tmp_reg__,%1+2)  CR_TAB
+                            AS2 (ldd,%D0,%1+3) CR_TAB
+                            AS2 (mov,%C0,__tmp_reg__));
+			  if(reg_base == REG_Z)
+            return *l=5, AVR_TINY ? (AS2 (ld ,%A0,Z+)       CR_TAB
+                            AS2 (ld,%B0,Z+) CR_TAB
+                            AS2 (ld,__tmp_reg__,Z+) CR_TAB
+                            AS2 (ld,%D0,Z) CR_TAB
+                            AS2 (subi,r30,lo8(3)) CR_TAB
+                            AS2 (sbci,r31,hi8(3)) CR_TAB
+                            AS2 (mov,%C0,__tmp_reg__))
+				             : (AS2 (ld ,%A0,%1)    CR_TAB
+                            AS2 (ldd,%B0,%1+1) CR_TAB
+                            AS2 (ldd,__tmp_reg__,%1+2)  CR_TAB
+                            AS2 (ldd,%D0,%1+3) CR_TAB
+                            AS2 (mov,%C0,__tmp_reg__));
+		  }
           else
-            return *l=4, (AS2 (ld ,%A0,%1)   CR_TAB
-                          AS2 (ldd,%B0,%1+1) CR_TAB
-                          AS2 (ldd,%C0,%1+2) CR_TAB
-                          AS2 (ldd,%D0,%1+3));
+		  {
+			  if(reg_base == REG_Y)
+            return *l=4, AVR_TINY ? (AS2 (ld ,%A0,Y+)   CR_TAB
+                            AS2 (ld,%B0,Y+) CR_TAB
+                            AS2 (ld,%C0,Y+) CR_TAB
+                            AS2 (ld,%D0,Y)  CR_TAB
+                            AS2 (subi,r28,lo8(3)) CR_TAB
+                            AS2 (sbci,r29,hi8(3)))
+						     : (AS2 (ld ,%A0,%1)   CR_TAB
+                            AS2 (ldd,%B0,%1+1) CR_TAB
+                            AS2 (ldd,%C0,%1+2) CR_TAB
+                            AS2 (ldd,%D0,%1+3));
+			  if(reg_base == REG_Z)
+            return *l=4, AVR_TINY ? (AS2 (ld ,%A0,Z+)   CR_TAB
+                            AS2 (ld,%B0,Z+) CR_TAB
+                            AS2 (ld,%C0,Z+) CR_TAB
+                            AS2 (ld,%D0,Z) CR_TAB
+                            AS2 (subi,r30,lo8(3)) CR_TAB
+                            AS2 (sbci,r31,hi8(3)))
+						     : (AS2 (ld ,%A0,%1)   CR_TAB
+                            AS2 (ldd,%B0,%1+1) CR_TAB
+                            AS2 (ldd,%C0,%1+2) CR_TAB
+                            AS2 (ldd,%D0,%1+3));
         }
     }
+    }
   else if (GET_CODE (base) == PLUS) /* (R + i) */
     {
       int disp = INTVAL (XEXP (base, 1));
@@ -2490,21 +2729,43 @@ out_movsi_r_mr (rtx insn, rtx op[], int *l)
 	    fatal_insn ("incorrect insn:",insn);
 
 	  if (disp <= 63 + MAX_LD_OFFSET (GET_MODE (src)))
-	    return *l = 6, (AS2 (adiw,r28,%o1-60) CR_TAB
-			    AS2 (ldd,%A0,Y+60)    CR_TAB
-			    AS2 (ldd,%B0,Y+61)    CR_TAB
-			    AS2 (ldd,%C0,Y+62)    CR_TAB
-			    AS2 (ldd,%D0,Y+63)    CR_TAB
-			    AS2 (sbiw,r28,%o1-60));
-
-	  return *l = 8, (AS2 (subi,r28,lo8(-%o1)) CR_TAB
-			  AS2 (sbci,r29,hi8(-%o1)) CR_TAB
-			  AS2 (ld,%A0,Y)           CR_TAB
-			  AS2 (ldd,%B0,Y+1)        CR_TAB
-			  AS2 (ldd,%C0,Y+2)        CR_TAB
-			  AS2 (ldd,%D0,Y+3)        CR_TAB
-			  AS2 (subi,r28,lo8(%o1))  CR_TAB
-			  AS2 (sbci,r29,hi8(%o1)));
+	    return *l = 6, AVR_TINY ? (AS2 (subi,r28,lo8(-(%o1-60))) CR_TAB
+						  AS2 (sbci,r29,hi8(-(%o1-60))) CR_TAB
+                          AS2 (subi,r28,lo8(-60)) CR_TAB
+                          AS2 (sbci,r29,hi8(-60)) CR_TAB
+						  AS2 (ld,%A0,Y+)    CR_TAB
+						  AS2 (ld,%B0,Y+)    CR_TAB
+						  AS2 (ld,%C0,Y+)    CR_TAB
+						  AS2 (ld,%D0,Y)    CR_TAB
+                          AS2 (subi,r28,lo8(63)) CR_TAB
+                          AS2 (sbci,r29,hi8(63)) CR_TAB
+                          AS2 (subi,r28,lo8(%o1-60)) CR_TAB
+                          AS2 (sbci,r29,hi8(%o1-60)))
+						   : (AS2 (adiw,r28,%o1-60) CR_TAB
+			              AS2 (ldd,%A0,Y+60)    CR_TAB
+			              AS2 (ldd,%B0,Y+61)    CR_TAB
+			              AS2 (ldd,%C0,Y+62)    CR_TAB
+			              AS2 (ldd,%D0,Y+63)    CR_TAB
+			              AS2 (sbiw,r28,%o1-60));
+
+	  return *l = 8, AVR_TINY ? (AS2 (subi,r28,lo8(-%o1)) CR_TAB
+						AS2 (sbci,r29,hi8(-%o1)) CR_TAB
+						AS2 (ld,%A0,Y+)           CR_TAB
+						AS2 (ld,%B0,Y+)           CR_TAB
+						AS2 (ld,%C0,Y+)           CR_TAB
+						AS2 (ld,%D0,Y)           CR_TAB
+                        AS2 (subi,r28,lo8(3))   CR_TAB
+                        AS2 (sbci,r29,hi8(3))   CR_TAB
+						AS2 (subi,r28,lo8(%o1))  CR_TAB
+						AS2 (sbci,r29,hi8(%o1)))
+			             : (AS2 (subi,r28,lo8(-%o1)) CR_TAB
+			            AS2 (sbci,r29,hi8(-%o1)) CR_TAB
+			            AS2 (ld,%A0,Y)           CR_TAB
+			            AS2 (ldd,%B0,Y+1)        CR_TAB
+			            AS2 (ldd,%C0,Y+2)        CR_TAB
+			            AS2 (ldd,%D0,Y+3)        CR_TAB
+			            AS2 (subi,r28,lo8(%o1))  CR_TAB
+			            AS2 (sbci,r29,hi8(%o1)));
 	}
 
       reg_base = true_regnum (XEXP (base, 0));
@@ -2515,46 +2776,151 @@ out_movsi_r_mr (rtx insn, rtx op[], int *l)
 	    {
 	      *l = 7;
 	      /* "ld r26,-X" is undefined */
-	      return (AS2 (adiw,r26,%o1+3)    CR_TAB
-		      AS2 (ld,r29,X)          CR_TAB
-		      AS2 (ld,r28,-X)         CR_TAB
-		      AS2 (ld,__tmp_reg__,-X) CR_TAB
-		      AS2 (sbiw,r26,1)        CR_TAB
-		      AS2 (ld,r26,X)          CR_TAB
-		      AS2 (mov,r27,__tmp_reg__));
+	      return AVR_TINY ? (AS2 (subi,r26,lo8(-(%o1+3)))  CR_TAB
+					AS2 (sbci,r27,hi8(-(%o1+3)))  CR_TAB
+					AS2 (ld,r29,X)          CR_TAB
+		            AS2 (ld,r28,-X)         CR_TAB
+		            AS2 (ld,__tmp_reg__,-X) CR_TAB
+                    AS2 (subi,r26,lo8(1))   CR_TAB
+                    AS2 (sbci,r27,hi8(1))   CR_TAB
+		            AS2 (ld,r26,X)          CR_TAB
+		            AS2 (mov,r27,__tmp_reg__))
+		             : (AS2 (adiw,r26,%o1+3)    CR_TAB
+		            AS2 (ld,r29,X)          CR_TAB
+		            AS2 (ld,r28,-X)         CR_TAB
+		            AS2 (ld,__tmp_reg__,-X) CR_TAB
+		            AS2 (sbiw,r26,1)        CR_TAB
+		            AS2 (ld,r26,X)          CR_TAB
+		            AS2 (mov,r27,__tmp_reg__));
 	    }
 	  *l = 6;
 	  if (reg_dest == REG_X - 2)
-	    return (AS2 (adiw,r26,%o1)      CR_TAB
-		    AS2 (ld,r24,X+)         CR_TAB
-		    AS2 (ld,r25,X+)         CR_TAB
-		    AS2 (ld,__tmp_reg__,X+) CR_TAB
-		    AS2 (ld,r27,X)          CR_TAB
-		    AS2 (mov,r26,__tmp_reg__));
-
-	  return (AS2 (adiw,r26,%o1) CR_TAB
-		  AS2 (ld,%A0,X+)    CR_TAB
-		  AS2 (ld,%B0,X+)    CR_TAB
-		  AS2 (ld,%C0,X+)    CR_TAB
-		  AS2 (ld,%D0,X)     CR_TAB
-		  AS2 (sbiw,r26,%o1+3));
+	    return AVR_TINY ? (AS2 (subi,r26,lo8(-(%o1))) CR_TAB
+				  AS2 (sbci,r27,hi8(-(%o1))) CR_TAB
+		          AS2 (ld,r24,X+)         CR_TAB
+		          AS2 (ld,r25,X+)         CR_TAB
+		          AS2 (ld,__tmp_reg__,X+) CR_TAB
+		          AS2 (ld,r27,X)          CR_TAB
+		          AS2 (mov,r26,__tmp_reg__))
+		           : (AS2 (adiw,r26,%o1)      CR_TAB
+		          AS2 (ld,r24,X+)         CR_TAB
+		          AS2 (ld,r25,X+)         CR_TAB
+		          AS2 (ld,__tmp_reg__,X+) CR_TAB
+		          AS2 (ld,r27,X)          CR_TAB
+		          AS2 (mov,r26,__tmp_reg__));
+
+	  return AVR_TINY ? (AS2 (subi,r26,lo8(-(%o1))) CR_TAB
+			    AS2 (sbci,r27,hi8(-(%o1))) CR_TAB
+		        AS2 (ld,%A0,X+)    CR_TAB
+		        AS2 (ld,%B0,X+)    CR_TAB
+		        AS2 (ld,%C0,X+)    CR_TAB
+		        AS2 (ld,%D0,X)     CR_TAB
+		        AS2 (subi,r26,lo8(%o1+3)) CR_TAB
+				AS2 (sbci,r27,hi8(%o1+3)))
+				 : (AS2 (adiw,r26,%o1) CR_TAB
+		        AS2 (ld,%A0,X+)    CR_TAB
+		        AS2 (ld,%B0,X+)    CR_TAB
+		        AS2 (ld,%C0,X+)    CR_TAB
+		        AS2 (ld,%D0,X)     CR_TAB
+		        AS2 (sbiw,r26,%o1+3));
 	}
       if (reg_dest == reg_base)
-        return *l=5, (AS2 (ldd,%D0,%D1) CR_TAB
-                      AS2 (ldd,%C0,%C1) CR_TAB
-                      AS2 (ldd,__tmp_reg__,%B1)  CR_TAB
-                      AS2 (ldd,%A0,%A1) CR_TAB
-                      AS2 (mov,%B0,__tmp_reg__));
+	  {
+			op[2] = XEXP(base, 0);
+
+		if(REGNO(op[2]) == REG_Y)
+        return *l=5, AVR_TINY ? (AS2 (subi,%A2,lo8(-(%o1+4))) CR_TAB
+						AS2 (sbci,%B2,hi8(-(%o1+4))) CR_TAB
+						AS2 (ld,%D0,-Y)               CR_TAB
+		                AS2 (ld,%C0,-Y)               CR_TAB
+		                AS2 (ld,__tmp_reg__,-Y)       CR_TAB
+		                AS2 (ld,%A0,-Y)               CR_TAB
+                        AS2 (subi,%A2,lo8(%o1)) CR_TAB
+						AS2 (sbci,%B2,hi8(%o1)) CR_TAB
+                        AS2 (mov,%B0,__tmp_reg__))
+			             : (AS2 (ldd,%D0,%D1) CR_TAB
+                        AS2 (ldd,%C0,%C1) CR_TAB
+                        AS2 (ldd,__tmp_reg__,%B1)  CR_TAB
+                        AS2 (ldd,%A0,%A1) CR_TAB
+                        AS2 (mov,%B0,__tmp_reg__));
+		if(REGNO(op[2]) == REG_Z)
+        return *l=5, AVR_TINY ? (AS2 (subi,%A2,lo8(-(%o1+4))) CR_TAB
+						AS2 (sbci,%B2,hi8(-(%o1+4))) CR_TAB
+						AS2 (ld,%D0,-Z)               CR_TAB
+		                AS2 (ld,%C0,-Z)               CR_TAB
+		                AS2 (ld,__tmp_reg__,-Z)       CR_TAB
+		                AS2 (ld,%A0,-Z)               CR_TAB
+                        AS2 (subi,%A2,lo8(%o1)) CR_TAB
+						AS2 (sbci,%B2,hi8(%o1)) CR_TAB
+                        AS2 (mov,%B0,__tmp_reg__))
+			             : (AS2 (ldd,%D0,%D1)			CR_TAB
+                        AS2 (ldd,%C0,%C1)			CR_TAB
+                        AS2 (ldd,__tmp_reg__,%B1)  CR_TAB
+                        AS2 (ldd,%A0,%A1)			CR_TAB
+                        AS2 (mov,%B0,__tmp_reg__));
+	  }
       else if (reg_dest == reg_base - 2)
-        return *l=5, (AS2 (ldd,%A0,%A1) CR_TAB
-                      AS2 (ldd,%B0,%B1) CR_TAB
-                      AS2 (ldd,__tmp_reg__,%C1)  CR_TAB
-                      AS2 (ldd,%D0,%D1) CR_TAB
-                      AS2 (mov,%C0,__tmp_reg__));
-      return *l=4, (AS2 (ldd,%A0,%A1) CR_TAB
-                    AS2 (ldd,%B0,%B1) CR_TAB
-                    AS2 (ldd,%C0,%C1) CR_TAB
-                    AS2 (ldd,%D0,%D1));
+	  {
+			op[2] = XEXP(base, 0);
+
+		if(REGNO(op[2]) == REG_Y)
+        return *l=5, AVR_TINY ? (AS2 (subi,%A2,lo8(-(%o1)))   CR_TAB
+						AS2 (subi,%B2,hi8(-(%o1)))   CR_TAB
+		                AS2 (ld,%A0,Y+)               CR_TAB
+		                AS2 (ld,%B0,Y+)               CR_TAB
+		                AS2 (ld,__tmp_reg__,Y+)       CR_TAB
+						AS2 (ld,%D0,Y)               CR_TAB
+						AS2 (subi,%A2,lo8(%o1+3)) CR_TAB
+						AS2 (sbci,%B2,hi8(%o1+3)) CR_TAB
+                        AS2 (mov,%C0,__tmp_reg__))
+			             : (AS2 (ldd,%A0,%A1)          CR_TAB
+                        AS2 (ldd,%B0,%B1) CR_TAB
+                        AS2 (ldd,__tmp_reg__,%C1)  CR_TAB
+                        AS2 (ldd,%D0,%D1) CR_TAB
+                        AS2 (mov,%C0,__tmp_reg__));
+		if(REGNO(op[2]) == REG_Z)
+        return *l=5, AVR_TINY ? (AS2 (subi,%A2,lo8(-(%o1)))   CR_TAB
+						AS2 (subi,%B2,hi8(-(%o1)))   CR_TAB
+		                AS2 (ld,%A0,Z+)              CR_TAB
+		                AS2 (ld,%B0,Z+)              CR_TAB
+		                AS2 (ld,__tmp_reg__,Z+)      CR_TAB
+						AS2 (ld,%D0,Z)               CR_TAB
+						AS2 (subi,%A2,lo8(%o1+3))    CR_TAB
+						AS2 (sbci,%B2,hi8(%o1+3))    CR_TAB
+                        AS2 (mov,%C0,__tmp_reg__))
+			             : (AS2 (ldd,%A0,%A1)          CR_TAB
+                        AS2 (ldd,%B0,%B1)          CR_TAB
+                        AS2 (ldd,__tmp_reg__,%C1)  CR_TAB
+                        AS2 (ldd,%D0,%D1)          CR_TAB
+                        AS2 (mov,%C0,__tmp_reg__));
+	  }
+			op[2] = XEXP(base, 0);
+		if(REGNO(op[2]) == REG_Y)
+        return *l=4, AVR_TINY ? (AS2 (subi,%A2,lo8(-(%o1)))   CR_TAB
+						AS2 (subi,%B2,hi8(-(%o1)))   CR_TAB
+		                AS2 (ld,%A0,Y+)               CR_TAB
+		                AS2 (ld,%B0,Y+)               CR_TAB
+		                AS2 (ld,%C0,Y+)               CR_TAB
+						AS2 (ld,%D0,Y)                CR_TAB
+						AS2 (subi,%A2,lo8(%o1+3)) CR_TAB
+						AS2 (sbci,%B2,hi8(%o1+3)))
+			             : (AS2 (ldd,%A0,%A1) CR_TAB
+                        AS2 (ldd,%B0,%B1) CR_TAB
+                        AS2 (ldd,%C0,%C1) CR_TAB
+                        AS2 (ldd,%D0,%D1));
+		if(REGNO(op[2]) == REG_Z)
+        return *l=4, AVR_TINY ? (AS2 (subi,%A2,lo8(-(%o1)))   CR_TAB
+						AS2 (subi,%B2,hi8(-(%o1)))   CR_TAB
+		                AS2 (ld,%A0,Z+)               CR_TAB
+		                AS2 (ld,%B0,Z+)               CR_TAB
+		                AS2 (ld,%C0,Z+)               CR_TAB
+						AS2 (ld,%D0,Z)               CR_TAB
+						AS2 (subi,%A2,lo8(%o1+3)) CR_TAB
+						AS2 (sbci,%B2,hi8(%o1+3)))
+			             : (AS2 (ldd,%A0,%A1) CR_TAB
+                        AS2 (ldd,%B0,%B1) CR_TAB
+                        AS2 (ldd,%C0,%C1) CR_TAB
+                        AS2 (ldd,%D0,%D1));
     }
   else if (GET_CODE (base) == PRE_DEC) /* (--R) */
     return *l=4, (AS2 (ld,%D0,%1) CR_TAB
@@ -2602,20 +2968,36 @@ out_movsi_mr_r (rtx insn, rtx op[], int *l)
             {
 	      /* "st X+,r26" is undefined */
               if (reg_unused_after (insn, base))
-		return *l=6, (AS2 (mov,__tmp_reg__,r27) CR_TAB
-			      AS2 (st,X,r26)            CR_TAB
-			      AS2 (adiw,r26,1)          CR_TAB
-			      AS2 (st,X+,__tmp_reg__)   CR_TAB
-			      AS2 (st,X+,r28)           CR_TAB
-			      AS2 (st,X,r29));
+		return *l=6, AVR_TINY ? (AS2 (mov,__tmp_reg__,r27) CR_TAB
+			            AS2 (st,X,r26)            CR_TAB
+			            AS2 (subi,r26,lo8(-1))    CR_TAB
+			            AS2 (sbci,r27,hi8(-1))    CR_TAB
+			            AS2 (st,X+,__tmp_reg__)   CR_TAB
+			            AS2 (st,X+,r28)           CR_TAB
+			            AS2 (st,X,r29))
+			             : (AS2 (mov,__tmp_reg__,r27) CR_TAB
+			            AS2 (st,X,r26)            CR_TAB
+			            AS2 (adiw,r26,1)          CR_TAB
+			            AS2 (st,X+,__tmp_reg__)   CR_TAB
+			            AS2 (st,X+,r28)           CR_TAB
+			            AS2 (st,X,r29));
               else
-                return *l=7, (AS2 (mov,__tmp_reg__,r27) CR_TAB
-			      AS2 (st,X,r26)            CR_TAB
-			      AS2 (adiw,r26,1)          CR_TAB
-			      AS2 (st,X+,__tmp_reg__)   CR_TAB
-			      AS2 (st,X+,r28)           CR_TAB
-			      AS2 (st,X,r29)            CR_TAB
-			      AS2 (sbiw,r26,3));
+        return *l=7, AVR_TINY ? (AS2 (mov,__tmp_reg__,r27) CR_TAB
+			            AS2 (st,X,r26)            CR_TAB
+			            AS2 (subi,r26,lo8(-1))    CR_TAB
+			            AS2 (sbci,r27,hi8(-1))    CR_TAB
+			            AS2 (st,X+,__tmp_reg__)   CR_TAB
+			            AS2 (st,X+,r28)           CR_TAB
+			            AS2 (st,X,r29)            CR_TAB
+			            AS2 (subi,r26,lo8(3))     CR_TAB
+			            AS2 (sbci,r27,hi8(3)))
+				         : (AS2 (mov,__tmp_reg__,r27) CR_TAB
+			            AS2 (st,X,r26)            CR_TAB
+			            AS2 (adiw,r26,1)          CR_TAB
+			            AS2 (st,X+,__tmp_reg__)   CR_TAB
+			            AS2 (st,X+,r28)           CR_TAB
+			            AS2 (st,X,r29)            CR_TAB
+			            AS2 (sbiw,r26,3));
             }
           else if (reg_base == reg_src + 2)
             {
@@ -2628,26 +3010,61 @@ out_movsi_mr_r (rtx insn, rtx op[], int *l)
                               AS2 (st,%0,__tmp_reg__)   CR_TAB
                               AS1 (clr,__zero_reg__));
               else
-                return *l=8, (AS2 (mov,__zero_reg__,%C1) CR_TAB
-                              AS2 (mov,__tmp_reg__,%D1) CR_TAB
-                              AS2 (st,%0+,%A1) CR_TAB
-                              AS2 (st,%0+,%B1) CR_TAB
-                              AS2 (st,%0+,__zero_reg__)  CR_TAB
-                              AS2 (st,%0,__tmp_reg__)   CR_TAB
-                              AS1 (clr,__zero_reg__)     CR_TAB
-                              AS2 (sbiw,r26,3));
+                return *l=8, AVR_TINY ? (AS2 (mov,__zero_reg__,%C1) CR_TAB
+                                AS2 (mov,__tmp_reg__,%D1)  CR_TAB
+                                AS2 (st,%0+,%A1)           CR_TAB
+                                AS2 (st,%0+,%B1)           CR_TAB
+                                AS2 (st,%0+,__zero_reg__)  CR_TAB
+                                AS2 (st,%0,__tmp_reg__)    CR_TAB
+                                AS1 (clr,__zero_reg__)     CR_TAB
+			                    AS2 (subi,r26,lo8(3))      CR_TAB
+			                    AS2 (sbci,r27,hi8(3)))
+					             : (AS2 (mov,__zero_reg__,%C1) CR_TAB
+                                AS2 (mov,__tmp_reg__,%D1) CR_TAB
+                                AS2 (st,%0+,%A1) CR_TAB
+                                AS2 (st,%0+,%B1) CR_TAB
+                                AS2 (st,%0+,__zero_reg__)  CR_TAB
+                                AS2 (st,%0,__tmp_reg__)   CR_TAB
+                                AS1 (clr,__zero_reg__)     CR_TAB
+                                AS2 (sbiw,r26,3));
             }
-          return *l=5, (AS2 (st,%0+,%A1)  CR_TAB
-                        AS2 (st,%0+,%B1) CR_TAB
-                        AS2 (st,%0+,%C1) CR_TAB
-                        AS2 (st,%0,%D1)  CR_TAB
-                        AS2 (sbiw,r26,3));
+          return *l=5, AVR_TINY ? (AS2 (st,%0+,%A1)  CR_TAB
+                          AS2 (st,%0+,%B1)  CR_TAB
+                          AS2 (st,%0+,%C1)  CR_TAB
+                          AS2 (st,%0,%D1)   CR_TAB
+			              AS2 (subi,r26,lo8(3))      CR_TAB
+			              AS2 (sbci,r27,hi8(3)))
+				           : (AS2 (st,%0+,%A1)  CR_TAB
+                          AS2 (st,%0+,%B1) CR_TAB
+                          AS2 (st,%0+,%C1) CR_TAB
+                          AS2 (st,%0,%D1)  CR_TAB
+                          AS2 (sbiw,r26,3));
         }
       else
-        return *l=4, (AS2 (st,%0,%A1)    CR_TAB
-		      AS2 (std,%0+1,%B1) CR_TAB
-		      AS2 (std,%0+2,%C1) CR_TAB
-		      AS2 (std,%0+3,%D1));
+	 {
+		 if(reg_base == REG_Y)
+        return *l=4, AVR_TINY ? (AS2 (st,Y+,%A1)        CR_TAB
+		                AS2 (st,Y+,%B1)        CR_TAB
+		                AS2 (st,Y+,%C1)        CR_TAB
+		                AS2 (st,Y,%D1)        CR_TAB
+				        AS2 (subi,r28,lo8(3)) CR_TAB
+				        AS2 (sbci,r29,lo8(3)))
+			             : (AS2 (st,%0,%A1)    CR_TAB
+		                AS2 (std,%0+1,%B1) CR_TAB
+		                AS2 (std,%0+2,%C1) CR_TAB
+		                AS2 (std,%0+3,%D1));
+		 if(reg_base == REG_Z)
+        return *l=4, AVR_TINY ? (AS2 (st,Z+,%A1)        CR_TAB
+		                AS2 (st,Z+,%B1)        CR_TAB
+		                AS2 (st,Z+,%C1)        CR_TAB
+		                AS2 (st,Z,%D1)        CR_TAB
+				        AS2 (subi,r30,lo8(3)) CR_TAB
+				        AS2 (sbci,r31,lo8(3)))
+			             : (AS2 (st,%0,%A1)    CR_TAB
+		                AS2 (std,%0+1,%B1) CR_TAB
+		                AS2 (std,%0+2,%C1) CR_TAB
+		                AS2 (std,%0+3,%D1));
+    }
     }
   else if (GET_CODE (base) == PLUS) /* (R + i) */
     {
@@ -2659,21 +3076,42 @@ out_movsi_mr_r (rtx insn, rtx op[], int *l)
 	    fatal_insn ("incorrect insn:",insn);
 
 	  if (disp <= 63 + MAX_LD_OFFSET (GET_MODE (dest)))
-	    return *l = 6, (AS2 (adiw,r28,%o0-60) CR_TAB
-			    AS2 (std,Y+60,%A1)    CR_TAB
-			    AS2 (std,Y+61,%B1)    CR_TAB
-			    AS2 (std,Y+62,%C1)    CR_TAB
-			    AS2 (std,Y+63,%D1)    CR_TAB
-			    AS2 (sbiw,r28,%o0-60));
-
-	  return *l = 8, (AS2 (subi,r28,lo8(-%o0)) CR_TAB
-			  AS2 (sbci,r29,hi8(-%o0)) CR_TAB
-			  AS2 (st,Y,%A1)           CR_TAB
-			  AS2 (std,Y+1,%B1)        CR_TAB
-			  AS2 (std,Y+2,%C1)        CR_TAB
-			  AS2 (std,Y+3,%D1)        CR_TAB
-			  AS2 (subi,r28,lo8(%o0))  CR_TAB
-			  AS2 (sbci,r29,hi8(%o0)));
+	    return *l = 6, AVR_TINY ? (AS2 (subi,r28,lo8(-(%o0-60))) CR_TAB
+				          AS2 (sbci,r29,hi8(-(%o0-60))) CR_TAB
+				          AS2 (subi,r28,lo8(-60)) CR_TAB
+				          AS2 (sbci,r29,lo8(-60)) CR_TAB
+			              AS2 (st,Y+,%A1)          CR_TAB
+			              AS2 (st,Y+,%B1)          CR_TAB
+			              AS2 (st,Y+,%C1)          CR_TAB
+			              AS2 (st,Y,%D1)          CR_TAB
+				          AS2 (subi,r28,lo8(63)) CR_TAB
+				          AS2 (sbci,r29,lo8(63)) CR_TAB
+			              AS2 (subi,r28,lo8(%o0-60)) CR_TAB
+			              AS2 (sbci,r29,hi8(%o0-60)))
+			               : (AS2 (adiw,r28,%o0-60) CR_TAB
+			              AS2 (std,Y+60,%A1)    CR_TAB
+			              AS2 (std,Y+61,%B1)    CR_TAB
+			              AS2 (std,Y+62,%C1)    CR_TAB
+			              AS2 (std,Y+63,%D1)    CR_TAB
+			              AS2 (sbiw,r28,%o0-60));
+	  return *l = 8, AVR_TINY ? (AS2 (subi,r28,lo8(-%o0)) CR_TAB
+			            AS2 (sbci,r29,hi8(-%o0)) CR_TAB
+			            AS2 (st,Y+,%A1)           CR_TAB
+			            AS2 (st,Y+,%B1)           CR_TAB
+			            AS2 (st,Y+,%C1)           CR_TAB
+			            AS2 (st,Y,%D1)           CR_TAB
+				        AS2 (subi,r28,lo8(3))   CR_TAB
+				        AS2 (sbci,r29,lo8(3))   CR_TAB
+			            AS2 (subi,r28,lo8(%o0))  CR_TAB
+			            AS2 (sbci,r29,hi8(%o0)))
+			             : (AS2 (subi,r28,lo8(-%o0)) CR_TAB
+			            AS2 (sbci,r29,hi8(-%o0)) CR_TAB
+			            AS2 (st,Y,%A1)           CR_TAB
+			            AS2 (std,Y+1,%B1)        CR_TAB
+			            AS2 (std,Y+2,%C1)        CR_TAB
+			            AS2 (std,Y+3,%D1)        CR_TAB
+			            AS2 (subi,r28,lo8(%o0))  CR_TAB
+			            AS2 (sbci,r29,hi8(%o0)));
 	}
       if (reg_base == REG_X)
 	{
@@ -2681,41 +3119,95 @@ out_movsi_mr_r (rtx insn, rtx op[], int *l)
 	  if (reg_src == REG_X)
 	    {
 	      *l = 9;
-	      return (AS2 (mov,__tmp_reg__,r26)  CR_TAB
-		      AS2 (mov,__zero_reg__,r27) CR_TAB
-		      AS2 (adiw,r26,%o0)         CR_TAB
-		      AS2 (st,X+,__tmp_reg__)    CR_TAB
-		      AS2 (st,X+,__zero_reg__)   CR_TAB
-		      AS2 (st,X+,r28)            CR_TAB
-		      AS2 (st,X,r29)             CR_TAB
-		      AS1 (clr,__zero_reg__)     CR_TAB
-		      AS2 (sbiw,r26,%o0+3));
+	      return AVR_TINY ? (AS2 (mov,__tmp_reg__,r26)  CR_TAB
+		            AS2 (mov,__zero_reg__,r27) CR_TAB
+	                AS2 (subi,r26,lo8(-(%o0))) CR_TAB
+			        AS2 (sbci,r27,hi8(-(%o0))) CR_TAB
+		            AS2 (st,X+,__tmp_reg__)    CR_TAB
+		            AS2 (st,X+,__zero_reg__)   CR_TAB
+		            AS2 (st,X+,r28)            CR_TAB
+		            AS2 (st,X,r29)             CR_TAB
+		            AS1 (clr,__zero_reg__)     CR_TAB
+					AS2 (subi,r26,lo8(%o0+3))  CR_TAB
+		            AS2 (sbci,r27,hi8(%o0+3)))
+			         : (AS2 (mov,__tmp_reg__,r26)  CR_TAB
+		            AS2 (mov,__zero_reg__,r27) CR_TAB
+		            AS2 (adiw,r26,%o0)         CR_TAB
+		            AS2 (st,X+,__tmp_reg__)    CR_TAB
+		            AS2 (st,X+,__zero_reg__)   CR_TAB
+		            AS2 (st,X+,r28)            CR_TAB
+		            AS2 (st,X,r29)             CR_TAB
+		            AS1 (clr,__zero_reg__)     CR_TAB
+		            AS2 (sbiw,r26,%o0+3));
 	    }
 	  else if (reg_src == REG_X - 2)
 	    {
 	      *l = 9;
-	      return (AS2 (mov,__tmp_reg__,r26)  CR_TAB
-		      AS2 (mov,__zero_reg__,r27) CR_TAB
-		      AS2 (adiw,r26,%o0)         CR_TAB
-		      AS2 (st,X+,r24)            CR_TAB
-		      AS2 (st,X+,r25)            CR_TAB
-		      AS2 (st,X+,__tmp_reg__)    CR_TAB
-		      AS2 (st,X,__zero_reg__)    CR_TAB
-		      AS1 (clr,__zero_reg__)     CR_TAB
-		      AS2 (sbiw,r26,%o0+3));
+	      return AVR_TINY ? (AS2 (mov,__tmp_reg__,r26)  CR_TAB
+		            AS2 (mov,__zero_reg__,r27) CR_TAB
+	                AS2 (subi,r26,lo8(-(%o0))) CR_TAB
+			        AS2 (sbci,r27,hi8(-(%o0))) CR_TAB
+		            AS2 (st,X+,r24)            CR_TAB
+		            AS2 (st,X+,r25)            CR_TAB
+		            AS2 (st,X+,__tmp_reg__)    CR_TAB
+		            AS2 (st,X,__zero_reg__)    CR_TAB
+		            AS1 (clr,__zero_reg__)     CR_TAB
+					AS2 (subi,r26,lo8(%o0+3)) CR_TAB
+		            AS2 (sbci,r27,hi8(%o0+3)))
+			         : (AS2 (mov,__tmp_reg__,r26)  CR_TAB
+		            AS2 (mov,__zero_reg__,r27) CR_TAB
+		            AS2 (adiw,r26,%o0)         CR_TAB
+		            AS2 (st,X+,r24)            CR_TAB
+		            AS2 (st,X+,r25)            CR_TAB
+		            AS2 (st,X+,__tmp_reg__)    CR_TAB
+		            AS2 (st,X,__zero_reg__)    CR_TAB
+		            AS1 (clr,__zero_reg__)     CR_TAB
+		            AS2 (sbiw,r26,%o0+3));
 	    }
 	  *l = 6;
-	  return (AS2 (adiw,r26,%o0) CR_TAB
-		  AS2 (st,X+,%A1)    CR_TAB
-		  AS2 (st,X+,%B1)    CR_TAB
-		  AS2 (st,X+,%C1)    CR_TAB
-		  AS2 (st,X,%D1)     CR_TAB
-		  AS2 (sbiw,r26,%o0+3));
+	  return AVR_TINY ? (AS2 (subi,r26,lo8(-(%o0))) CR_TAB
+			    AS2 (sbci,r27,hi8(-(%o0))) CR_TAB
+		        AS2 (st,X+,%A1)    CR_TAB
+		        AS2 (st,X+,%B1)    CR_TAB
+		        AS2 (st,X+,%C1)    CR_TAB
+		        AS2 (st,X,%D1)     CR_TAB
+				AS2 (subi,r26,lo8(%o0+3)) CR_TAB
+		        AS2 (sbci,r27,hi8(%o0+3)))
+		         : (AS2 (adiw,r26,%o0) CR_TAB
+		        AS2 (st,X+,%A1)    CR_TAB
+		        AS2 (st,X+,%B1)    CR_TAB
+		        AS2 (st,X+,%C1)    CR_TAB
+		        AS2 (st,X,%D1)     CR_TAB
+		        AS2 (sbiw,r26,%o0+3));
 	}
-      return *l=4, (AS2 (std,%A0,%A1)    CR_TAB
-		    AS2 (std,%B0,%B1) CR_TAB
-		    AS2 (std,%C0,%C1) CR_TAB
-		    AS2 (std,%D0,%D1));
+		op[2] = XEXP(base, 0);
+		if(REGNO(op[2]) == REG_Y)
+      return *l=4, AVR_TINY ? (AS2 (subi,%A2,lo8(-(%o0)))    CR_TAB
+					  AS2 (sbci,%B2,hi8(-(%o0)))    CR_TAB
+		              AS2 (st,Y+,%A1)               CR_TAB
+		              AS2 (st,Y+,%B1)               CR_TAB
+		              AS2 (st,Y+,%C1)               CR_TAB
+		              AS2 (st,Y,%D1)                CR_TAB
+					  AS2 (subi,%A2,lo8(%o0+3))     CR_TAB
+					  AS2 (sbci,%B2,hi8(%o0+3)))
+		               : (AS2 (std,%A0,%A1)    CR_TAB
+		              AS2 (std,%B0,%B1)    CR_TAB
+		              AS2 (std,%C0,%C1)    CR_TAB
+		              AS2 (std,%D0,%D1));
+
+		if(REGNO(op[2]) == REG_Z)
+      return *l=4, AVR_TINY ? (AS2 (subi,%A2,lo8(-(%o0)))    CR_TAB
+					  AS2 (sbci,%B2,hi8(-(%o0)))    CR_TAB
+		              AS2 (st,Z+,%A1)              CR_TAB
+		              AS2 (st,Z+,%B1)             CR_TAB
+		              AS2 (st,Z+,%C1)             CR_TAB
+		              AS2 (st,Z,%D1)              CR_TAB
+					  AS2 (subi,%A2,lo8(%o0+3))    CR_TAB
+					  AS2 (sbci,%B2,hi8(%o0+3)))
+		               : (AS2 (std,%A0,%A1)    CR_TAB
+		              AS2 (std,%B0,%B1) CR_TAB
+		              AS2 (std,%C0,%C1) CR_TAB
+		              AS2 (std,%D0,%D1));
     }
   else if (GET_CODE (base) == PRE_DEC) /* (--R) */
     return *l=4, (AS2 (st,%0,%D1) CR_TAB
@@ -2929,9 +3421,18 @@ out_movqi_mr_r (rtx insn, rtx op[], int *l)
 	    fatal_insn ("incorrect insn:",insn);
 
 	  if (disp <= 63 + MAX_LD_OFFSET (GET_MODE (dest)))
-	    return *l = 3, (AS2 (adiw,r28,%o0-63) CR_TAB
-			    AS2 (std,Y+63,%1)     CR_TAB
-			    AS2 (sbiw,r28,%o0-63));
+	    return *l = 3, AVR_TINY ? (AS2 (subi,r28,lo8(-(%o0-63))) CR_TAB
+				          AS2 (sbci,r29,hi8(-(%o0-63))) CR_TAB
+						  AS2 (subi,r28,lo8(-63)) CR_TAB
+						  AS2 (sbci,r29,hi8(-63)) CR_TAB
+			              AS2 (st,Y,%1)           CR_TAB
+						  AS2 (subi,r28,lo8(63)) CR_TAB
+						  AS2 (sbci,r29,hi8(63)) CR_TAB
+				          AS2 (subi,r28,lo8(%o0-63)) CR_TAB
+			              AS2 (sbci,r29,hi8(%o0-63)))
+			               : (AS2 (adiw,r28,%o0-63) CR_TAB
+			              AS2 (std,Y+63,%1)     CR_TAB
+			              AS2 (sbiw,r28,%o0-63));
 
 	  return *l = 5, (AS2 (subi,r28,lo8(-%o0)) CR_TAB
 			  AS2 (sbci,r29,hi8(-%o0)) CR_TAB
@@ -2944,28 +3445,60 @@ out_movqi_mr_r (rtx insn, rtx op[], int *l)
 	  if (reg_overlap_mentioned_p (src, XEXP (x, 0)))
 	    {
 	      if (reg_unused_after (insn, XEXP (x,0)))
-		return *l = 3, (AS2 (mov,__tmp_reg__,%1) CR_TAB
-				AS2 (adiw,r26,%o0)       CR_TAB
-				AS2 (st,X,__tmp_reg__));
-
-	      return *l = 4, (AS2 (mov,__tmp_reg__,%1) CR_TAB
-			      AS2 (adiw,r26,%o0)       CR_TAB
-			      AS2 (st,X,__tmp_reg__)   CR_TAB
-			      AS2 (sbiw,r26,%o0));
+		return *l = 3, AVR_TINY ? (AS2 (mov,__tmp_reg__,%1) CR_TAB
+			              AS2 (subi,r26,lo8(-(%o0)))       CR_TAB
+			              AS2 (sbci,r27,hi8(-(%o0)))       CR_TAB
+				          AS2 (st,X,__tmp_reg__))
+			               : (AS2 (mov,__tmp_reg__,%1) CR_TAB
+				          AS2 (adiw,r26,%o0)       CR_TAB
+				          AS2 (st,X,__tmp_reg__));
+
+	      return *l = 4, AVR_TINY ? (AS2 (mov,__tmp_reg__,%1) CR_TAB
+			                AS2 (subi,r26,lo8(-(%o0)))       CR_TAB
+			                AS2 (sbci,r27,hi8(-(%o0)))       CR_TAB
+			                AS2 (st,X,__tmp_reg__)   CR_TAB
+			                AS2 (subi,r26,lo8(%o0))       CR_TAB
+			                AS2 (sbci,r27,hi8(%o0)))
+				             : (AS2 (mov,__tmp_reg__,%1) CR_TAB
+			                AS2 (adiw,r26,%o0)       CR_TAB
+			                AS2 (st,X,__tmp_reg__)   CR_TAB
+			                AS2 (sbiw,r26,%o0));
 	    }
 	  else
 	    {
 	      if (reg_unused_after (insn, XEXP (x,0)))
-		return *l = 2, (AS2 (adiw,r26,%o0) CR_TAB
-				AS2 (st,X,%1));
-
-	      return *l = 3, (AS2 (adiw,r26,%o0) CR_TAB
-			      AS2 (st,X,%1)      CR_TAB
-			      AS2 (sbiw,r26,%o0));
+		return *l = 2, AVR_TINY ? (AS2 (subi,r26,lo8(-(%o0)))       CR_TAB
+			              AS2 (sbci,r27,hi8(-(%o0)))       CR_TAB
+				          AS2 (st,X,%1))
+			               : (AS2 (adiw,r26,%o0) CR_TAB
+				          AS2 (st,X,%1));
+
+	      return *l = 3, AVR_TINY ? (AS2 (subi,r26,lo8(-(%o0)))       CR_TAB
+			                AS2 (sbci,r27,hi8(-(%o0)))       CR_TAB
+			                AS2 (st,X,%1)                    CR_TAB
+			                AS2 (subi,r26,lo8(%o0))          CR_TAB
+			                AS2 (sbci,r27,hi8(%o0)))
+							 : (AS2 (adiw,r26,%o0) CR_TAB
+			                AS2 (st,X,%1)      CR_TAB
+			                AS2 (sbiw,r26,%o0));
 	    }
 	}
       *l = 1;
-      return AS2 (std,%0,%1);
+	  op[2] = XEXP(x, 0);
+	  if(REGNO(op[2]) == REG_Y)
+      return AVR_TINY ? (AS2 (subi,%A2,lo8(-(%o0))) CR_TAB
+				AS2 (sbci,%B2,hi8(-(%o0))) CR_TAB
+		        AS2 (st,Y,%1)              CR_TAB
+                AS2 (subi,%A2,lo8(%o0)) CR_TAB
+				AS2 (sbci,%B2,hi8(%o0)))
+		         :  AS2 (std,%0,%1);
+	  if(REGNO(op[2]) == REG_Z)
+      return AVR_TINY ? (AS2 (subi,%A2,lo8(-(%o0))) CR_TAB
+				AS2 (sbci,%B2,hi8(-(%o0))) CR_TAB
+		        AS2 (st,Z,%1)              CR_TAB
+                AS2 (subi,%A2,lo8(%o0)) CR_TAB
+				AS2 (sbci,%B2,hi8(%o0)))
+		         :  AS2 (std,%0,%1);
     }
   *l = 1;
   return AS2 (st,%0,%1);
@@ -3014,24 +3547,43 @@ out_movhi_mr_r (rtx insn, rtx op[], int *l)
             {
               /* "st X+,r26" and "st -X,r26" are undefined.  */
               if (!mem_volatile_p && reg_unused_after (insn, src))
-		return *l=4, (AS2 (mov,__tmp_reg__,r27) CR_TAB
-			      AS2 (st,X,r26)            CR_TAB
-			      AS2 (adiw,r26,1)          CR_TAB
-			      AS2 (st,X,__tmp_reg__));
+		return *l=4, AVR_TINY ? (AS2 (mov,__tmp_reg__,r27)  CR_TAB
+			            AS2 (st,X,r26)             CR_TAB
+			            AS2 (subi,r26,lo8(-1))     CR_TAB
+			            AS2 (sbci,r27,hi8(-1))     CR_TAB
+			            AS2 (st,X,__tmp_reg__))
+			             : (AS2 (mov,__tmp_reg__,r27)  CR_TAB
+			            AS2 (st,X,r26)            CR_TAB
+			            AS2 (adiw,r26,1)          CR_TAB
+			            AS2 (st,X,__tmp_reg__));
               else
 	        {
                   if (!AVR_XMEGA)
-		return *l=5, (AS2 (mov,__tmp_reg__,r27) CR_TAB
-			      AS2 (adiw,r26,1)          CR_TAB
-			      AS2 (st,X,__tmp_reg__)    CR_TAB
-                              AS2 (sbiw,r26,1)          CR_TAB
-                              AS2 (st,X,r26));
+		    return *l=5, AVR_TINY ? (AS2 (mov,__tmp_reg__,r27) CR_TAB
+							AS2 (subi,r26,lo8(-1))    CR_TAB
+							AS2 (sbci,r27,hi8(-1))    CR_TAB
+							AS2 (st,X,__tmp_reg__)    CR_TAB
+							AS2 (subi,r26,lo8(1))     CR_TAB
+							AS2 (sbci,r27,hi8(1))     CR_TAB
+							AS2 (st,X,r26))
+							 : (AS2 (mov,__tmp_reg__,r27) CR_TAB
+			                AS2 (adiw,r26,1)          CR_TAB
+			                AS2 (st,X,__tmp_reg__)    CR_TAB
+                            AS2 (sbiw,r26,1)          CR_TAB
+                            AS2 (st,X,r26));
 		  else
-		    return *l=5, (AS2 (mov,__tmp_reg__,r27) CR_TAB
-			          AS2 (st,X,r26)            CR_TAB
-			          AS2 (adiw,r26,1)          CR_TAB
-			          AS2 (st,X,__tmp_reg__)    CR_TAB
-			          AS2 (sbiw,r26,1));
+		    return *l=5, AVR_TINY ? (AS2 (mov,__tmp_reg__,r27) CR_TAB
+			                AS2 (st,X,r26)            CR_TAB
+						    AS2 (subi,r26,lo8(-1))    CR_TAB
+						    AS2 (sbci,r27,hi8(-1))    CR_TAB
+			                AS2 (st,X,__tmp_reg__)    CR_TAB
+						    AS2 (subi,r26,lo8(1))     CR_TAB
+						    AS2 (sbci,r27,hi8(1)))
+				             : (AS2 (mov,__tmp_reg__,r27) CR_TAB
+			                AS2 (st,X,r26)            CR_TAB
+			                AS2 (adiw,r26,1)          CR_TAB
+			                AS2 (st,X,__tmp_reg__)    CR_TAB
+			                AS2 (sbiw,r26,1));
 		}
             }
           else
@@ -3042,26 +3594,62 @@ out_movhi_mr_r (rtx insn, rtx op[], int *l)
               else
 		{
                   if (!AVR_XMEGA)
-                return *l=3, (AS2 (adiw,r26,1) CR_TAB
-                              AS2 (st,X,%B1)   CR_TAB
-                              AS2 (st,-X,%A1));
+                    return *l=3, AVR_TINY ? (AS2 (subi,r26,lo8(-1)) CR_TAB
+							        AS2 (sbci,r27,hi8(-1)) CR_TAB
+                                    AS2 (st,X,%B1)         CR_TAB
+                                    AS2 (st,-X,%A1))
+						             : (AS2 (adiw,r26,1) CR_TAB
+                                    AS2 (st,X,%B1)   CR_TAB
+                                    AS2 (st,-X,%A1));
 	          else
-                    return *l=3, (AS2 (st,X+,%A1) CR_TAB
-                                  AS2 (st,X,%B1) CR_TAB
-                                  AS2 (sbiw,r26,1));
+                    return *l=3, AVR_TINY ? (AS2 (st,X+,%A1) CR_TAB
+                                    AS2 (st,X,%B1) CR_TAB
+						            AS2 (subi,r26,lo8(1))     CR_TAB
+						            AS2 (sbci,r27,hi8(1)))
+						             : (AS2 (st,X+,%A1) CR_TAB
+                                    AS2 (st,X,%B1) CR_TAB
+                                    AS2 (sbiw,r26,1));
 		}
             }
         }
       else
         {
 	  if (!AVR_XMEGA)
-        return  *l=2, (AS2 (std,%0+1,%B1) CR_TAB
-                       AS2 (st,%0,%A1));
+	  {
+		    if(reg_base == REG_Y)
+            return  *l=2, AVR_TINY ? (AS2 (subi,r28,lo8(-1))  CR_TAB
+			                 AS2 (sbci,r29,hi8(-1))  CR_TAB
+                             AS2 (st,Y,%B1)         CR_TAB
+                             AS2 (st,-Y,%A1))
+				              : (AS2 (std,%0+1,%B1)      CR_TAB
+                             AS2 (st,%0,%A1));
+		    if(reg_base == REG_Z)
+            return  *l=2, AVR_TINY ? (AS2 (subi,r30,lo8(-1))  CR_TAB
+			                 AS2 (sbci,r31,hi8(-1))  CR_TAB
+                             AS2 (st,Z,%B1)         CR_TAB
+                             AS2 (st,-Z,%A1))
+				              : (AS2 (std,%0+1,%B1)      CR_TAB
+                             AS2 (st,%0,%A1));
+	  }
 	  else
-            return  *l=2, (AS2 (st,%0,%A1)    CR_TAB
-                           AS2 (std,%0+1,%B1));
+	  {
+		    if(reg_base == REG_Y)
+            return  *l=2, AVR_TINY ? (AS2 (st,Y+,%A1)        CR_TAB
+                             AS2 (st,Y,%B1)        CR_TAB
+					         AS2 (subi,r28,lo8(1))  CR_TAB
+			                 AS2 (sbci,r29,hi8(1)))
+					          : (AS2 (st,%0,%A1)    CR_TAB
+                             AS2 (std,%0+1,%B1));
+		    if(reg_base == REG_Z)
+            return  *l=2, AVR_TINY ? (AS2 (st,Z+,%A1)         CR_TAB
+                             AS2 (st,Z,%B1)         CR_TAB
+					         AS2 (subi,r30,lo8(1))  CR_TAB
+			                 AS2 (sbci,r31,hi8(1)))
+					          : (AS2 (st,%0,%A1)    CR_TAB
+                             AS2 (std,%0+1,%B1));
         }
     }
+    }
   else if (GET_CODE (base) == PLUS)
     {
       int disp = INTVAL (XEXP (base, 1));
@@ -3074,32 +3662,68 @@ out_movhi_mr_r (rtx insn, rtx op[], int *l)
           if (!AVR_XMEGA)
             {
 	  if (disp <= 63 + MAX_LD_OFFSET (GET_MODE (dest)))
-	    return *l = 4, (AS2 (adiw,r28,%o0-62) CR_TAB
-			    AS2 (std,Y+63,%B1)    CR_TAB
-			    AS2 (std,Y+62,%A1)    CR_TAB
-			    AS2 (sbiw,r28,%o0-62));
-
-	  return *l = 6, (AS2 (subi,r28,lo8(-%o0)) CR_TAB
-			  AS2 (sbci,r29,hi8(-%o0)) CR_TAB
-			  AS2 (std,Y+1,%B1)        CR_TAB
-			  AS2 (st,Y,%A1)           CR_TAB
-			  AS2 (subi,r28,lo8(%o0))  CR_TAB
-			  AS2 (sbci,r29,hi8(%o0)));
+	        return *l = 4, AVR_TINY ? (AS2 (subi,r28,lo8(-(%o0-62))) CR_TAB
+					          AS2 (sbci,r29,hi8(-(%o0-62))) CR_TAB
+							  AS2 (subi,r28,lo8(-63))       CR_TAB
+							  AS2 (sbci,r29,hi8(-63))       CR_TAB
+			                  AS2 (st,Y,%B1)				 CR_TAB
+			                  AS2 (st,-Y,%A1)				 CR_TAB
+							  AS2 (subi,r28,lo8(62))       CR_TAB
+							  AS2 (sbci,r29,hi8(62))       CR_TAB
+			                  AS2 (subi,r28,lo8(%o0-62))    CR_TAB
+			                  AS2 (sbci,r29,hi8(%o0-62)))
+				               : (AS2 (adiw,r28,%o0-62) CR_TAB
+			                  AS2 (std,Y+63,%B1)    CR_TAB
+			                  AS2 (std,Y+62,%A1)    CR_TAB
+			                  AS2 (sbiw,r28,%o0-62));
+
+	      return *l = 6, AVR_TINY ? (AS2 (subi,r28,lo8(-%o0)) CR_TAB
+			                AS2 (sbci,r29,hi8(-%o0)) CR_TAB
+							AS2 (subi,r28,lo8(-1))   CR_TAB
+							AS2 (sbci,r29,hi8(-1))   CR_TAB
+			                AS2 (st,Y,%B1)           CR_TAB
+			                AS2 (st,-Y,%A1)           CR_TAB
+			                AS2 (subi,r28,lo8(%o0))  CR_TAB
+			                AS2 (sbci,r29,hi8(%o0)))
+				             : (AS2 (subi,r28,lo8(-%o0)) CR_TAB
+			                AS2 (sbci,r29,hi8(-%o0)) CR_TAB
+			                AS2 (std,Y+1,%B1)        CR_TAB
+			                AS2 (st,Y,%A1)           CR_TAB
+			                AS2 (subi,r28,lo8(%o0))  CR_TAB
+			                AS2 (sbci,r29,hi8(%o0)));
 	}
 	  else
 	    {
 	      if (disp <= 63 + MAX_LD_OFFSET (GET_MODE (dest)))
-	        return *l = 4, (AS2 (adiw,r28,%o0-62) CR_TAB
-			        AS2 (std,Y+62,%A1)    CR_TAB
-			        AS2 (std,Y+63,%B1)    CR_TAB
-			        AS2 (sbiw,r28,%o0-62));
-
-	      return *l = 6, (AS2 (subi,r28,lo8(-%o0)) CR_TAB
-			      AS2 (sbci,r29,hi8(-%o0)) CR_TAB
-			      AS2 (st,Y,%A1)           CR_TAB
-			      AS2 (std,Y+1,%B1)        CR_TAB
-			      AS2 (subi,r28,lo8(%o0))  CR_TAB
-			      AS2 (sbci,r29,hi8(%o0)));
+	        return *l = 4, AVR_TINY ? (AS2 (subi,r28,lo8(-(%o0-62))) CR_TAB
+					          AS2 (sbci,r29,hi8(-(%o0-62))) CR_TAB
+							  AS2 (subi,r28,lo8(-62))       CR_TAB
+							  AS2 (sbci,r29,hi8(-62))       CR_TAB
+			                  AS2 (st,Y+,%A1)				 CR_TAB
+			                  AS2 (st,Y,%B1)				 CR_TAB
+							  AS2 (subi,r28,lo8(63))       CR_TAB
+							  AS2 (sbci,r29,hi8(63))       CR_TAB
+			                  AS2 (subi,r28,lo8(%o0-62))    CR_TAB
+			                  AS2 (sbci,r29,hi8(%o0-62)))
+				               : (AS2 (adiw,r28,%o0-62) CR_TAB
+			                  AS2 (std,Y+62,%A1)    CR_TAB
+			                  AS2 (std,Y+63,%B1)    CR_TAB
+			                  AS2 (sbiw,r28,%o0-62));
+
+	      return *l = 6, AVR_TINY ? (AS2 (subi,r28,lo8(-%o0)) CR_TAB
+			                AS2 (sbci,r29,hi8(-%o0)) CR_TAB
+			                AS2 (st,Y+,%A1)           CR_TAB
+			                AS2 (st,Y,%B1)           CR_TAB
+							AS2 (subi,r28,lo8(1))   CR_TAB
+							AS2 (sbci,r29,hi8(1))   CR_TAB
+			                AS2 (subi,r28,lo8(%o0))  CR_TAB
+			                AS2 (sbci,r29,hi8(%o0)))
+				             : (AS2 (subi,r28,lo8(-%o0)) CR_TAB
+			                AS2 (sbci,r29,hi8(-%o0)) CR_TAB
+			                AS2 (st,Y,%A1)           CR_TAB
+			                AS2 (std,Y+1,%B1)        CR_TAB
+			                AS2 (subi,r28,lo8(%o0))  CR_TAB
+			                AS2 (sbci,r29,hi8(%o0)));
 	    }
 	}
       if (reg_base == REG_X)
@@ -3110,50 +3734,119 @@ out_movhi_mr_r (rtx insn, rtx op[], int *l)
 	      if (!AVR_XMEGA)
 	        {
 	      *l = 7;
-	      return (AS2 (mov,__tmp_reg__,r26)  CR_TAB
-		      AS2 (mov,__zero_reg__,r27) CR_TAB
-                      AS2 (adiw,r26,%o0+1)       CR_TAB
-		      AS2 (st,X,__zero_reg__)    CR_TAB
-		      AS2 (st,-X,__tmp_reg__)    CR_TAB
-		      AS1 (clr,__zero_reg__)     CR_TAB
-                      AS2 (sbiw,r26,%o0));
+	          return AVR_TINY ? (AS2 (mov,__tmp_reg__,r26)  CR_TAB
+		                AS2 (mov,__zero_reg__,r27) CR_TAB
+                        AS2 (subi,r26,lo8(-(%o0+1)))   CR_TAB
+                        AS2 (sbci,r27,hi8(-(%o0+1)))   CR_TAB
+		                AS2 (st,X,__zero_reg__)    CR_TAB
+		                AS2 (st,-X,__tmp_reg__)    CR_TAB
+		                AS1 (clr,__zero_reg__)     CR_TAB
+                        AS2 (subi,r26,lo8(%o0))    CR_TAB
+                        AS2 (sbci,r27,hi8(%o0)))
+				         : (AS2 (mov,__tmp_reg__,r26)  CR_TAB
+		                AS2 (mov,__zero_reg__,r27) CR_TAB
+                        AS2 (adiw,r26,%o0+1)       CR_TAB
+		                AS2 (st,X,__zero_reg__)    CR_TAB
+		                AS2 (st,-X,__tmp_reg__)    CR_TAB
+		                AS1 (clr,__zero_reg__)     CR_TAB
+                        AS2 (sbiw,r26,%o0));
 	    }
 	      else
 	        {
 	          *l = 7;
-	          return (AS2 (mov,__tmp_reg__,r26)  CR_TAB
-		          AS2 (mov,__zero_reg__,r27) CR_TAB
-		          AS2 (adiw,r26,%o0)         CR_TAB
-		          AS2 (st,X+,__tmp_reg__)    CR_TAB
-		          AS2 (st,X,__zero_reg__)    CR_TAB
-		          AS1 (clr,__zero_reg__)     CR_TAB
-		          AS2 (sbiw,r26,%o0+1));
+			  return AVR_TINY ? (AS2 (mov,__tmp_reg__,r26)  CR_TAB
+		                AS2 (mov,__zero_reg__,r27) CR_TAB
+				        AS2 (subi,r26,lo8(-(%o0)))   CR_TAB
+				        AS2 (sbci,r27,hi8(-(%o0)))   CR_TAB
+		                AS2 (st,X+,__tmp_reg__)    CR_TAB
+		                AS2 (st,X,__zero_reg__)    CR_TAB
+		                AS1 (clr,__zero_reg__)     CR_TAB
+				        AS2 (subi,r26,lo8(%o0+1))    CR_TAB
+				        AS2 (sbci,r27,hi8(%o0+1)))
+				         : (AS2 (mov,__tmp_reg__,r26)  CR_TAB
+						AS2 (mov,__zero_reg__,r27) CR_TAB
+						AS2 (adiw,r26,%o0+1)       CR_TAB
+						AS2 (st,X+,__tmp_reg__)    CR_TAB
+						AS2 (st,X,__zero_reg__)    CR_TAB
+						AS1 (clr,__zero_reg__)     CR_TAB
+						AS2 (sbiw,r26,%o0));
+
 	        }
 	    }
 	  if (!AVR_XMEGA)
             {
 	  *l = 4;
-          return (AS2 (adiw,r26,%o0+1) CR_TAB
-                  AS2 (st,X,%B1)       CR_TAB
-                  AS2 (st,-X,%A1)      CR_TAB
-                  AS2 (sbiw,r26,%o0));
+              return AVR_TINY ? (AS2 (subi,r26,lo8(-(%o0+1)))   CR_TAB
+                        AS2 (sbci,r27,hi8(-(%o0+1)))   CR_TAB
+                        AS2 (st,X,%B1)       CR_TAB
+                        AS2 (st,-X,%A1)      CR_TAB
+                        AS2 (subi,r26,lo8(%o0))    CR_TAB
+                        AS2 (sbci,r27,hi8(%o0)))
+				         : (AS2 (adiw,r26,%o0+1) CR_TAB
+                        AS2 (st,X,%B1)       CR_TAB
+                        AS2 (st,-X,%A1)      CR_TAB
+                        AS2 (sbiw,r26,%o0));
 	}
 	  else
 	    {
 	      *l = 4;
-	      return (AS2 (adiw,r26,%o0) CR_TAB
-		      AS2 (st,X+,%A1)    CR_TAB
-		      AS2 (st,X,%B1)     CR_TAB
-		      AS2 (sbiw,r26,%o0+1));
+              return AVR_TINY ? (AS2 (subi,r26,lo8(-(%o0)))   CR_TAB
+                        AS2 (sbci,r27,hi8(-(%o0)))   CR_TAB
+                        AS2 (st,X+,%A1)       CR_TAB
+                        AS2 (st,X,%B1)      CR_TAB
+                        AS2 (subi,r26,lo8(%o0))    CR_TAB
+                        AS2 (sbci,r27,hi8(%o0)))
+				         : (AS2 (adiw,r26,%o0) CR_TAB
+		                AS2 (st,X+,%A1)    CR_TAB
+		                AS2 (st,X,%B1)     CR_TAB
+		                AS2 (sbiw,r26,%o0+1));
             }
 	}
 
       if (!AVR_XMEGA)
-      return *l=2, (AS2 (std,%B0,%B1)    CR_TAB
-                    AS2 (std,%A0,%A1));
+	  {
+		op[2] = XEXP(base, 0);
+		if(REGNO(op[2]) == REG_Y)
+        return *l=2, AVR_TINY ? (AS2 (subi,%A2,lo8(-(%o0+2)))    CR_TAB
+						AS2 (sbci,%B2,hi8(-(%o0+2)))    CR_TAB
+						AS2 (st,-Y,%B1)                  CR_TAB
+                        AS2 (st,-Y,%A1)                  CR_TAB
+                        AS2 (subi,%A2,lo8(%o0))    CR_TAB
+						AS2 (sbci,%B2,hi8(%o0)))
+			             : (AS2 (std,%B0,%B1)    CR_TAB
+                        AS2 (std,%A0,%A1));
+		if(REGNO(op[2]) == REG_Z)
+        return *l=2, AVR_TINY ? (AS2 (subi,%A2,lo8(-(%o0+1)))    CR_TAB
+						AS2 (sbci,%B2,hi8(-(%o0+1)))    CR_TAB
+						AS2 (st,-Z,%B1)                  CR_TAB
+                        AS2 (st,-Z,%A1)                  CR_TAB
+                        AS2 (subi,%A2,lo8(%o0))    CR_TAB
+						AS2 (sbci,%B2,hi8(%o0)))
+			             : (AS2 (std,%B0,%B1)    CR_TAB
+                        AS2 (std,%A0,%A1));
+	  }
       else
-        return *l=2, (AS2 (std,%A0,%A1)    CR_TAB
-	              AS2 (std,%B0,%B1));
+	  {
+		op[2] = XEXP(base, 0);
+		if(REGNO(op[2]) == REG_Y)
+        return *l=2, AVR_TINY ? (AS2 (subi,%A2,lo8(-(%o0)))    CR_TAB
+						AS2 (sbci,%B2,hi8(-(%o0)))    CR_TAB
+                        AS2 (st,Y+,%A1)                CR_TAB
+						AS2 (st,Y,%B1)                 CR_TAB
+				        AS2 (subi,%A2,lo8(%o0+1))    CR_TAB
+						AS2 (sbci,%B2,hi8(%o0+1)))
+                         : (AS2 (std,%A0,%A1)    CR_TAB
+	                    AS2 (std,%B0,%B1));
+		if(REGNO(op[2]) == REG_Z)
+        return *l=2, AVR_TINY ? (AS2 (subi,%A2,lo8(-(%o0)))    CR_TAB
+						AS2 (sbci,%B2,hi8(-(%o0)))    CR_TAB
+                        AS2 (st,Z+,%A1)                CR_TAB
+						AS2 (st,Z,%B1)                CR_TAB
+				        AS2 (subi,%A2,lo8(%o0+1))    CR_TAB
+						AS2 (sbci,%B2,hi8(%o0+1)))
+                         : (AS2 (std,%A0,%A1)    CR_TAB
+	                    AS2 (std,%B0,%B1));
+	  }
     }
   else if (GET_CODE (base) == PRE_DEC) /* (--R) */
     {
@@ -3173,17 +3866,32 @@ out_movhi_mr_r (rtx insn, rtx op[], int *l)
           if (REGNO (XEXP (base, 0)) == REG_X)
             {
               *l = 4;
-              return (AS2 (adiw,r26,1)  CR_TAB
-                      AS2 (st,X,%B1)    CR_TAB
-                      AS2 (st,-X,%A1)   CR_TAB
-                      AS2 (adiw,r26,2));
+              return AVR_TINY ? (AS2 (subi,r26,lo8(-1))  CR_TAB
+					    AS2 (sbci,r27,hi8(-1))  CR_TAB
+                        AS2 (st,X,%B1)    CR_TAB
+                        AS2 (st,-X,%A1)   CR_TAB
+						AS2 (subi,r26,lo8(-2)) CR_TAB
+						AS2 (sbci,r27,hi8(-2)))
+				         : (AS2 (adiw,r26,1)  CR_TAB
+                        AS2 (st,X,%B1)    CR_TAB
+                        AS2 (st,-X,%A1)   CR_TAB
+                        AS2 (adiw,r26,2));
             }
           else
             {
+			  //FIXME:check the code once again for AVR_TINY
               *l = 3;
-              return (AS2 (std,%p0+1,%B1) CR_TAB
-                      AS2 (st,%p0,%A1)    CR_TAB
-                      AS2 (adiw,%r0,2));
+              return AVR_TINY ? (AS2 (subi,%A0,lo8(-1)) CR_TAB
+						AS2 (sbci,%B0,hi8(-1)) CR_TAB
+						AS2 (st,%p0,%B1)       CR_TAB
+                        AS2 (subi,%A0,lo8(1)) CR_TAB
+						AS2 (sbci,%B0,hi8(1)) CR_TAB
+                        AS2 (st,%p0,%A1)       CR_TAB
+                        AS2 (subi,%A0,lo8(-3)) CR_TAB
+					    AS2 (sbci,%B0,hi8(-3)))
+				         : (AS2 (std,%p0+1,%B1) CR_TAB
+                        AS2 (st,%p0,%A1)    CR_TAB
+                        AS2 (adiw,%r0,2));
             }
         }
 
@@ -3271,7 +3979,9 @@ out_tsthi (rtx insn, int *l)
   if (test_hard_reg_class (ADDW_REGS, SET_SRC (PATTERN (insn))))
     {
       if (l) *l = 1;
-      return AS2 (sbiw,%0,0);
+      return AVR_TINY ? (AS2 (subi,%A0,lo8(0)) CR_TAB
+				AS2 (sbci,%B0,hi8(0)))
+		         :  AS2 (sbiw,%0,0);
     }
   if (l) *l = 2;
   return (AS2 (cp,%A0,__zero_reg__) CR_TAB
@@ -3292,9 +4002,13 @@ out_tstsi (rtx insn, int *l)
   if (test_hard_reg_class (ADDW_REGS, SET_SRC (PATTERN (insn))))
     {
       if (l) *l = 3;
-      return (AS2 (sbiw,%A0,0) CR_TAB
-              AS2 (cpc,%C0,__zero_reg__) CR_TAB
-              AS2 (cpc,%D0,__zero_reg__));
+      return AVR_TINY ? (AS2 (subi,%A0,lo8(-(-0))) CR_TAB
+				AS2 (sbci,%B0,hi8(-(-0))) CR_TAB
+                AS2 (cpc,%C0,__zero_reg__) CR_TAB
+                AS2 (cpc,%D0,__zero_reg__))
+		         : (AS2 (sbiw,%A0,0) CR_TAB
+                AS2 (cpc,%C0,__zero_reg__) CR_TAB
+                AS2 (cpc,%D0,__zero_reg__));
     }
   if (l) *l = 4;
   return (AS2 (cp,%A0,__zero_reg__) CR_TAB
@@ -5560,10 +6274,12 @@ avr_file_start (void)
 /*  fprintf (asm_out_file, "\t.arch %s\n", avr_mcu_name);*/
   fputs ("__SREG__ = 0x3f\n"
 	 "__SP_H__ = 0x3e\n"
-	 "__SP_L__ = 0x3d\n"
-	 "__CCP__  = 0x34\n", asm_out_file);
+	 "__SP_L__ = 0x3d\n", asm_out_file);
+
+  AVR_TINY ? fputs ("__CCP__ = 0x3c\n", asm_out_file) : fputs ("__CCP__ = 0x34\n", asm_out_file);
   
-  fputs ("__tmp_reg__ = 0\n" 
+  AVR_TINY ? fputs ("__tmp_reg__ = 16\n"
+		            "__zero_reg__ = 17\n", asm_out_file) : fputs ("__tmp_reg__ = 0\n"
          "__zero_reg__ = 1\n", asm_out_file);
 }
 
diff --git a/gcc/config/avr/avr.h b/gcc/config/avr/avr.h
index b0d5d60..c947c39 100644
--- a/gcc/config/avr/avr.h
+++ b/gcc/config/avr/avr.h
@@ -50,6 +50,9 @@ struct base_arch_s {
   /* Core have RAMPX, RAMPY and RAMPD registers.  */
   int have_rampx_y_d;
   
+  /* Core is in tiny 10/20/9/4/5/40. */
+  int avrtiny;
+
   const char *const macro;
 };
 
@@ -102,6 +105,10 @@ extern const struct base_arch_s *avr_current_arch;
 	  builtin_define ("__AVR_XMEGA__");     \
 	  builtin_define ("__AVR_HAVE_SPMX__"); \
 	}					\
+      if (avr_current_arch->avrtiny)              \
+	{					\
+	  builtin_define ("__AVR_TINY__");     \
+	}					\
       if (avr_current_arch->have_rampx_y_d)     \
 	{					\
 	  builtin_define ("__AVR_HAVE_RAMPX__");\
@@ -124,12 +131,13 @@ extern GTY(()) section *progmem_section;
 #define AVR_HAVE_RAMPZ (avr_current_arch->have_elpm)
 #define AVR_HAVE_EIJMP_EICALL (avr_current_arch->have_eijmp_eicall)
 #define AVR_XMEGA (avr_current_arch->xmega)
+#define AVR_TINY  (avr_current_arch->avrtiny)
 #define AVR_HAVE_RAMPX_Y_D (avr_current_arch->have_rampx_y_d)
 
 #define AVR_2_BYTE_PC (!AVR_HAVE_EIJMP_EICALL)
 #define AVR_3_BYTE_PC (AVR_HAVE_EIJMP_EICALL)
 
-#define AVR_IO_OFFSET (AVR_XMEGA ? 0 : 0x20)
+#define AVR_IO_OFFSET ((AVR_XMEGA || AVR_TINY) ? 0 : 0x20)
 #define AVR_RAMPD_ADDR (AVR_XMEGA ? 0x38 : 0)
 #define AVR_RAMPX_ADDR (AVR_XMEGA ? 0x39 : 0)
 #define AVR_RAMPY_ADDR (AVR_XMEGA ? 0x3A : 0)
@@ -248,7 +256,6 @@ extern GTY(()) section *progmem_section;
 
 #define ORDER_REGS_FOR_LOCAL_ALLOC order_regs_for_local_alloc ()
 
-
 #define HARD_REGNO_NREGS(REGNO, MODE) ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
 
 #define HARD_REGNO_MODE_OK(REGNO, MODE) avr_hard_regno_mode_ok(REGNO, MODE)
@@ -312,6 +319,41 @@ enum reg_class {
   {0xffffffff,0x00000003}	/* ALL_REGS */				\
 }
 
+/* Zero or more C statements that may conditionally modify five variables
+   fixed_regs, call_used_regs, global_regs, reg_names, and reg_class_contents,
+   to take into account any dependence of these register sets on target flags.
+   The first three of these are of type char [] (interpreted as Boolean
+   vectors). global_regs is a const char *[], and reg_class_contents is a
+   HARD_REG_SET. Before the macro is called, fixed_regs, call_used_regs,
+   reg_class_contents, and reg_names have been initialized from
+   FIXED_REGISTERS, CALL_USED_REGISTERS, REG_CLASS_CONTENTS, and
+   REGISTER_NAMES, respectively. global_regs has been cleared, and any
+   ‘-ffixed-reg’, ‘-fcall-used-reg’ and ‘-fcall-saved-reg’ command options
+   have been applied.
+
+   You need not define this macro if it has no work to do.
+
+   If the usage of an entire class of registers depends on the target flags,
+   you may indicate this to GCC by using this macro to modify fixed_regs and
+   call_used_regs to 1 for each of the registers in the classes which should
+   not be used by GCC. Also define the macro REG_CLASS_FROM_LETTER /
+   REG_CLASS_FROM_CONSTRAINT to return NO_REGS if it is called with a letter
+   for a class that shouldn’t be used.  (However, if this class is not included
+   in GENERAL_REGS and all of the insn patterns whose constraints permit this
+   class are controlled by target switches, then GCC will automatically avoid
+   using these registers when the target switches are opposed to them.) */
+
+#define CONDITIONAL_REGISTER_USAGE             \
+   if (AVR_TINY) {                             \
+     int i;                                    \
+     for (i = 0;  i <= 17;  i++) {             \
+       fixed_regs[i] = 1;                      \
+       call_used_regs[i] = 1;                  \
+     }                                         \
+	CLEAR_HARD_REG_SET(reg_class_contents[(int)ADDW_REGS]);           \
+	CLEAR_HARD_REG_SET(reg_class_contents[(int)NO_LD_REGS]);           \
+   }
+
 #define REGNO_REG_CLASS(R) avr_regno_reg_class(R)
 
 /* The following macro defines cover classes for Integrated Register
@@ -1232,7 +1274,14 @@ mmcu=*:-mmcu=%*}"
 %{mmcu=atxmega256a3b:crtx256a3b.o%s} \
 %{mmcu=atxmega256d3:crtx256d3.o%s} \
 %{mmcu=atxmega7|mmcu=atxmega128a1:crtx128a1.o%s} \
-%{mmcu=atxmega128a1u:crtx128a1u.o%s}"
+%{mmcu=atxmega128a1u:crtx128a1u.o%s} \
+%{mmcu=attiny4:crttn4.o%s} \
+%{mmcu=attiny5:crttn5.o%s} \
+%{mmcu=attiny9:crttn9.o%s} \
+%{mmcu=avrtiny10|mmcu=attiny10:crttn10.o%s} \
+%{mmcu=attiny20:crttn20.o%s} \
+%{mmcu=attiny40:crttn40.o%s}"
+
 
 #define EXTRA_SPECS {"crt_binutils", CRT_BINUTILS_SPECS},
 
diff --git a/gcc/config/avr/avr.md b/gcc/config/avr/avr.md
index f91e98c..96ef48e 100644
--- a/gcc/config/avr/avr.md
+++ b/gcc/config/avr/avr.md
@@ -181,6 +181,9 @@
   DONE;
 })
 
+(define_constants
+ [(TMP_REGNO_AVRTINY10	16)	; temporary register r16
+  (ZERO_REGNO_AVRTINY10	17)])	; zero register r17
 
 (define_insn "*push<ALLQ:mode>"
   [(set (mem:ALLQ (post_dec (reg:HI REG_SP)))
@@ -474,7 +477,7 @@
   rtx addr1 = copy_to_mode_reg (Pmode, XEXP (operands[1], 0));
 
   /* Create rtx for tmp register - we use this as scratch.  */
-  rtx tmp_reg_rtx  = gen_rtx_REG (QImode, TMP_REGNO);
+  rtx tmp_reg_rtx  = gen_rtx_REG (QImode, AVR_TINY ? TMP_REGNO_AVRTINY10 : TMP_REGNO);
 
   if (GET_CODE (operands[2]) != CONST_INT)
     FAIL;
@@ -2955,7 +2958,7 @@
 			UNSPEC_INDEX_JMP))
    (use (label_ref (match_operand 1 "" "")))
    (clobber (match_dup 0))]
-  "AVR_HAVE_JMP_CALL && !AVR_HAVE_EIJMP_EICALL"
+  "(AVR_HAVE_JMP_CALL && !AVR_HAVE_EIJMP_EICALL)"
   "lsl r30
 	rol r31
 	lpm
diff --git a/gcc/config/avr/libgcc-fixed.S b/gcc/config/avr/libgcc-fixed.S
index a694ee6..73d0ad1 100644
--- a/gcc/config/avr/libgcc-fixed.S
+++ b/gcc/config/avr/libgcc-fixed.S
@@ -29,13 +29,17 @@ Boston, MA 02110-1301, USA.  */
 
 /* Fixed point library routines for avr.  */
 
+#if defined (__AVR_TINY__)
+#define __zero_reg__ r17
+#define __tmp_reg__ r16
+#else
 #define __zero_reg__ r1
 #define __tmp_reg__ r0
+#endif
 #define __SREG__ 0x3f
 #define __SP_H__ 0x3e
 #define __SP_L__ 0x3d
 #define __RAMPZ__ 0x3B
-
 /* Conversions to float.  */
 #if defined (L_fractqqsf)
         .global __fractqqsf
@@ -281,15 +285,15 @@ __muluqq3_exit:
 	.func	__mulhq3
 __mulhq3:
         fmuls   r_arg1H, r_arg2H
-        movw    r_resL, r0
+        movw    r_resL, __tmp_reg__
         fmulsu  r_arg2H, r_arg1L
         clr     r_arg1L
         sbc     r_resH, r_arg1L
-        add     r_resL, r1
+        add     r_resL, __zero_reg__
         adc     r_resH, r_arg1L
         fmulsu  r_arg1H, r_arg2L
         sbc     r_resH, r_arg1L
-        add     r_resL, r1
+        add     r_resL, __zero_reg__
         adc     r_resH, r_arg1L
         clr     __zero_reg__
         ret
@@ -301,13 +305,13 @@ __mulhq3:
 	.func	__muluhq3
 __muluhq3:
         mul     r_arg1H, r_arg2H
-        movw    r_resL, r0
+        movw    r_resL, __tmp_reg__
         mul     r_arg1H, r_arg2L
-        add     r_resL, r1
+        add     r_resL, __zero_reg__
         clr     __zero_reg__
         adc     r_resH, __zero_reg__
         mul     r_arg1L, r_arg2H
-        add     r_resL, r1
+        add     r_resL, __zero_reg__
         clr     __zero_reg__
         adc     r_resH, __zero_reg__
         ret
@@ -401,15 +405,15 @@ __muluhq3_skip:
 	.func	__mulha3
 __mulha3:
         mul     r_arg1L, r_arg2L
-        mov     r_resL, r1
+        mov     r_resL, __zero_reg__
         muls    r_arg1H, r_arg2H
-        mov     r_resH, r0
+        mov     r_resH, __tmp_reg__
         mulsu   r_arg1H, r_arg2L
-        add     r_resL, r0
-        adc     r_resH, r1
+        add     r_resL, __tmp_reg__
+        adc     r_resH, __zero_reg__
         mulsu   r_arg2H, r_arg1L
-        add     r_resL, r0
-        adc     r_resH, r1
+        add     r_resL, __tmp_reg__
+        adc     r_resH, __zero_reg__
         clr     __zero_reg__
         ret
 .endfunc
@@ -420,15 +424,15 @@ __mulha3:
 	.func	__muluha3
 __muluha3:
         mul     r_arg1L, r_arg2L
-        mov     r_resL, r1
+        mov     r_resL, __zero_reg__
         mul     r_arg1H, r_arg2H
-        mov     r_resH, r0
+        mov     r_resH, __tmp_reg__
         mul     r_arg1H, r_arg2L
-        add     r_resL, r0
-        adc     r_resH, r1
+        add     r_resL, __tmp_reg__
+        adc     r_resH, __zero_reg__
         mul     r_arg1L, r_arg2H
-        add     r_resL, r0
-        adc     r_resH, r1
+        add     r_resL, __tmp_reg__
+        adc     r_resH, __zero_reg__
         clr     __zero_reg__
         ret
 .endfunc
@@ -442,8 +446,8 @@ __muluha3:
 #define	r_arg2H	r23		/* multiplicand High */
 #define r_resL	r18     	/* result Low */
 #define r_resH  r19	        /* result High */
-#define r_scratchL  r0     	/* scratch Low */
-#define r_scratchH  r1
+#define r_scratchL  __tmp_reg__     	/* scratch Low */
+#define r_scratchH  __zero_reg__
 
 #if defined (L_mulha3)
 	.global	__mulha3
@@ -480,8 +484,8 @@ __mulha3_exit:
 __muluha3:
 	clr	r_resL		; clear result
         clr     r_resH
-        mov_l   r0, r_arg1L     ; save multiplicand
-        mov_h   r1, r_arg1H
+        mov_l   __tmp_reg__, r_arg1L     ; save multiplicand
+        mov_h   __zero_reg__, r_arg1H
 __muluha3_loop1:
         sbrs	r_arg2H,0
 	rjmp	__muluha3_skip1
@@ -490,7 +494,12 @@ __muluha3_loop1:
 __muluha3_skip1:
 	lsl	r_arg1L		; shift multiplicand
 	rol	r_arg1H
+#if defined (__AVR_TINY__)
+        subi    r_arg1L, lo8(0)
+        sbci    r_arg1L, hi8(0)
+#else
         sbiw    r_arg1L,0
+#endif
         breq    __muluha3_loop1_done ; exit multiplicand = 0
         lsr     r_arg2H
         brne    __muluha3_loop1 ; exit multiplier = 0
@@ -500,7 +509,12 @@ __muluha3_loop1_done:
 __muluha3_loop2:
 	lsr	r_arg1H		; shift multiplicand
 	ror	r_arg1L
+#if defined (__AVR_TINY__)
+        subi    r_arg1L, lo8(0)
+        sbci    r_arg1L, hi8(0)
+#else
         sbiw    r_arg1L,0
+#endif
         breq    __muluha3_exit  ; exit if multiplicand = 0
         sbrs    r_arg2L,7
         rjmp    __muluha3_skip2
@@ -556,53 +570,53 @@ __mulsa3:
         clr     r_resHL
         clr     r_resHH
         mul     r_arg1H, r_arg2L
-        mov     r_resL, r1
+        mov     r_resL, __zero_reg__
         mul     r_arg1L, r_arg2H
-        add     r_resL, r1
+        add     r_resL, __zero_reg__
         adc     r_resH, r_clr
         mul     r_arg1L, r_arg2HL
-        add     r_resL, r0
-        adc     r_resH, r1
+        add     r_resL, __tmp_reg__
+        adc     r_resH, __zero_reg__
         adc     r_resHL, r_clr
         mul     r_arg1H, r_arg2H
-        add     r_resL, r0
-        adc     r_resH, r1
+        add     r_resL, __tmp_reg__
+        adc     r_resH, __zero_reg__
         adc     r_resHL, r_clr
         mul     r_arg1HL, r_arg2L
-        add     r_resL, r0
-        adc     r_resH, r1
+        add     r_resL, __tmp_reg__
+        adc     r_resH, __zero_reg__
         adc     r_resHL, r_clr
         mulsu   r_arg2HH, r_arg1L
         sbc     r_resHH, r_clr
-        add     r_resH, r0
-        adc     r_resHL, r1
+        add     r_resH, __tmp_reg__
+        adc     r_resHL, __zero_reg__
         adc     r_resHH, r_clr
         mul     r_arg1H, r_arg2HL
-        add     r_resH, r0
-        adc     r_resHL, r1
+        add     r_resH, __tmp_reg__
+        adc     r_resHL, __zero_reg__
         adc     r_resHH, r_clr
         mul     r_arg1HL, r_arg2H
-        add     r_resH, r0
-        adc     r_resHL, r1
+        add     r_resH, __tmp_reg__
+        adc     r_resHL, __zero_reg__
         adc     r_resHH, r_clr
         mulsu   r_arg1HH, r_arg2L
         sbc     r_resHH, r_clr
-        add     r_resH, r0
-        adc     r_resHL, r1
+        add     r_resH, __tmp_reg__
+        adc     r_resHL, __zero_reg__
         adc     r_resHH, r_clr
         mulsu   r_arg2HH, r_arg1H
-        add     r_resHL, r0
-        adc     r_resHH, r1
+        add     r_resHL, __tmp_reg__
+        adc     r_resHH, __zero_reg__
         mul     r_arg1HL, r_arg2HL
-        add     r_resHL, r0
-        adc     r_resHH, r1
+        add     r_resHL, __tmp_reg__
+        adc     r_resHH, __zero_reg__
         mulsu   r_arg1HH, r_arg2H
-        add     r_resHL, r0
-        adc     r_resHH, r1
+        add     r_resHL, __tmp_reg__
+        adc     r_resHH, __zero_reg__
         mulsu   r_arg2HH, r_arg1HL
-        add     r_resHH, r0
+        add     r_resHH, __tmp_reg__
         mulsu   r_arg1HH, r_arg2HL
-        add     r_resHH, r0
+        add     r_resHH, __tmp_reg__
         clr     __zero_reg__
         ret
 .endfunc
@@ -617,51 +631,51 @@ __mulusa3:
         clr     r_resHL
         clr     r_resHH
         mul     r_arg1H, r_arg2L
-        mov     r_resL, r1
+        mov     r_resL, __zero_reg__
         mul     r_arg1L, r_arg2H
-        add     r_resL, r1
+        add     r_resL, __zero_reg__
         adc     r_resH, r_clr
         mul     r_arg1L, r_arg2HL
-        add     r_resL, r0
-        adc     r_resH, r1
+        add     r_resL, __tmp_reg__
+        adc     r_resH, __zero_reg__
         adc     r_resHL, r_clr
         mul     r_arg1H, r_arg2H
-        add     r_resL, r0
-        adc     r_resH, r1
+        add     r_resL, __tmp_reg__
+        adc     r_resH, __zero_reg__
         adc     r_resHL, r_clr
         mul     r_arg1HL, r_arg2L
-        add     r_resL, r0
-        adc     r_resH, r1
+        add     r_resL, __tmp_reg__
+        adc     r_resH, __zero_reg__
         adc     r_resHL, r_clr
         mul     r_arg1L, r_arg2HH
-        add     r_resH, r0
-        adc     r_resHL, r1
+        add     r_resH, __tmp_reg__
+        adc     r_resHL, __zero_reg__
         adc     r_resHH, r_clr
         mul     r_arg1H, r_arg2HL
-        add     r_resH, r0
-        adc     r_resHL, r1
+        add     r_resH, __tmp_reg__
+        adc     r_resHL, __zero_reg__
         adc     r_resHH, r_clr
         mul     r_arg1HL, r_arg2H
-        add     r_resH, r0
-        adc     r_resHL, r1
+        add     r_resH, __tmp_reg__
+        adc     r_resHL, __zero_reg__
         adc     r_resHH, r_clr
         mul     r_arg1HH, r_arg2L
-        add     r_resH, r0
-        adc     r_resHL, r1
+        add     r_resH, __tmp_reg__
+        adc     r_resHL, __zero_reg__
         adc     r_resHH, r_clr
         mul     r_arg1H, r_arg2HH
-        add     r_resHL, r0
-        adc     r_resHH, r1
+        add     r_resHL, __tmp_reg__
+        adc     r_resHH, __zero_reg__
         mul     r_arg1HL, r_arg2HL
-        add     r_resHL, r0
-        adc     r_resHH, r1
+        add     r_resHL, __tmp_reg__
+        adc     r_resHH, __zero_reg__
         mul     r_arg1HH, r_arg2H
-        add     r_resHL, r0
-        adc     r_resHH, r1
+        add     r_resHL, __tmp_reg__
+        adc     r_resHH, __zero_reg__
         mul     r_arg1HL, r_arg2HH
-        add     r_resHH, r0
+        add     r_resHH, __tmp_reg__
         mul     r_arg1HH, r_arg2HL
-        add     r_resHH, r0
+        add     r_resHH, __tmp_reg__
         clr     __zero_reg__
         ret
 .endfunc
@@ -680,13 +694,20 @@ __mulusa3:
 #define	r_arg2HL r26
 #define	r_arg2HH r27		/* multiplicand High */
 
+#if defined (__AVR_TINY__)
+#define r_resL	 r28    	/* result Low */
+#define r_resH   r29
+#define r_resHL	 r30
+#define r_resHH  r31	        /* result High */
+#else
 #define r_resL	 r14     	/* result Low */
 #define r_resH   r15
 #define r_resHL	 r16
 #define r_resHH  r17	        /* result High */
+#endif
 
-#define r_scratchL  r0     	/* scratch Low */
-#define r_scratchH  r1
+#define r_scratchL  __tmp_reg__     	/* scratch Low */
+#define r_scratchH  __zero_reg__
 #define r_scratchHL r22
 #define r_scratchHH r23	        /* scratch High */
 
@@ -758,7 +779,12 @@ __mulusa3_skip1:
 	rol	r_arg1HH
         lsr     r_arg2HH
         ror     r_arg2HL
+#if defined (__AVR_TINY__)
+        subi    r_arg2HL, lo8(0)
+        sbci    r_arg2HL, hi8(0)
+#else
         sbiw    r_arg2HL,0
+#endif
         brne    __mulusa3_loop1 ; exit multiplier = 0
 __mulusa3_loop1_done:
         mov_l   r_arg1L, r_scratchL     ; restore multiplicand
@@ -779,7 +805,12 @@ __mulusa3_loop2:
 __mulusa3_skip2:
         lsl     r_arg2L
         rol     r_arg2H
+#if defined (__AVR_TINY__)
+        subi    r_arg2L, lo8(0)
+        sbci    r_arg2L, hi8(0)
+#else
         sbiw    r_arg2L,0
+#endif
         brne    __mulusa3_loop2 ; exit if multiplier = 0
 __mulusa3_exit:
         clr     __zero_reg__    ; got clobbered
@@ -791,9 +822,7 @@ __mulusa3_exit:
 #undef r_scratchH
 #undef r_scratchHL
 #undef r_scratchHH
-
 #endif
-
 #undef	r_arg1L
 #undef	r_arg1H
 #undef	r_arg1HL
@@ -821,8 +850,8 @@ __mulusa3_exit:
 	.global	__divqq3
 	.func	__divqq3
 __divqq3:
-        mov     r0, r_divd
-        eor     r0, r_div
+        mov     __tmp_reg__, r_divd
+        eor     __tmp_reg__, r_div
         sbrc    r_div, 7
         neg     r_div
         sbrc    r_divd, 7
@@ -831,7 +860,7 @@ __divqq3:
         breq    __divqq3_minus1  ; if equal return -1
         rcall   __udivuqq3
         lsr     r_quo
-        sbrc    r0, 7   ; negate result if needed
+        sbrc    __tmp_reg__, 7   ; negate result if needed
         neg     r_quo
         ret
 __divqq3_minus1:
@@ -886,8 +915,8 @@ __udivuqq3_cont:
 	.global	__divhq3
 	.func	__divhq3
 __divhq3:
-        mov     r0, r_divdH
-        eor     r0, r_divH
+        mov     __tmp_reg__, r_divdH
+        eor     __tmp_reg__, r_divH
         sbrs    r_divH, 7
         rjmp    __divhq3_divpos
         com     r_divH
@@ -906,7 +935,7 @@ __divhq3_divdpos:
         rcall   __udivuhq3
         lsr     r_quoH
         ror     r_quoL
-        sbrs    r0, 7   ; negate result if needed
+        sbrs    __tmp_reg__, 7   ; negate result if needed
         ret
         com     r_quoH
         neg     r_quoL
@@ -958,8 +987,8 @@ __udivuhq3_cont:
 	.global	__divha3
 	.func	__divha3
 __divha3:
-        mov     r0, r_divdH
-        eor     r0, r_divH
+        mov     __tmp_reg__, r_divdH
+        eor     __tmp_reg__, r_divH
         sbrs    r_divH, 7
         rjmp    __divha3_divpos
         com     r_divH
@@ -973,7 +1002,7 @@ __divha3_divpos:
         sbci    r_divdH,-1
 __divha3_divdpos:
         rcall   __udivuha3
-        sbrs    r0, 7   ; negate result if needed
+        sbrs    __tmp_reg__, 7   ; negate result if needed
         ret
         com     r_quoH
         neg     r_quoL
@@ -1027,8 +1056,8 @@ __udivuha3:
 	.global	__divsa3
 	.func	__divsa3
 __divsa3:
-        mov     r0, r27
-        eor     r0, r_divHH
+        mov     __tmp_reg__, r27
+        eor     __tmp_reg__, r_divHH
         sbrs    r_divHH, 7
         rjmp    __divsa3_divpos
         com     r_divHH
@@ -1050,7 +1079,7 @@ __divsa3_divpos:
         sbci    r_arg1HH,-1
 __divsa3_arg1pos:
         rcall   __udivusa3
-        sbrs    r0, 7   ; negate result if needed
+        sbrs    __tmp_reg__, 7   ; negate result if needed
         ret
         com     r_quoHH
         com     r_quoHL
diff --git a/gcc/config/avr/libgcc.S b/gcc/config/avr/libgcc.S
index 5a711a8..eda75a1 100644
--- a/gcc/config/avr/libgcc.S
+++ b/gcc/config/avr/libgcc.S
@@ -22,8 +22,13 @@ a copy of the GCC Runtime Library Exception along with this program;
 see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
+#if defined (__AVR_TINY__)
+#define __zero_reg__ r17
+#define __tmp_reg__ r16
+#else
 #define __zero_reg__ r1
 #define __tmp_reg__ r0
+#endif
 #define __SREG__ 0x3f
 #define __SP_H__ 0x3e
 #define __SP_L__ 0x3d
@@ -140,7 +145,12 @@ __mulhi3_skip1:
 
 	lsr	r_arg1H		; gets LSB of multiplier
 	ror	r_arg1L
+#if defined (__AVR_TINY__)
+    subi    r_arg1L, lo8(0)
+    sbci    r_arg1L, hi8(0)
+#else
 	sbiw	r_arg1L,0
+#endif
 	brne	__mulhi3_loop	; exit if multiplier = 0
 __mulhi3_exit:
 	mov	r_arg1H,r_resH	; result to return register
@@ -304,7 +314,12 @@ __mulsi3_skip1:
 	ror	r_arg1H
 	ror	r_arg1L
 	brne	__mulsi3_loop
+#if defined (__AVR_TINY__)
+    subi    r_arg1HL, lo8(0)
+    sbci    r_arg1HL, hi8(0)
+#else
 	sbiw	r_arg1HL,0
+#endif
 	cpc	r_arg1H,r_arg1L
 	brne	__mulsi3_loop		; exit if multiplier = 0
 __mulsi3_exit:
@@ -610,6 +625,7 @@ __divmodsi4_neg1:
 /**********************************
  * This is a prologue subroutine
  **********************************/
+#if !defined (__AVR_TINY__)
 #if defined (L_prologue)
 
 	.global	__prologue_saves__
@@ -663,7 +679,6 @@ __prologue_saves__:
  * This is an epilogue subroutine
  */
 #if defined (L_epilogue)
-
 	.global	__epilogue_restores__
 	.func	__epilogue_restores__
 __epilogue_restores__:
@@ -704,6 +719,7 @@ __epilogue_restores__:
 	ret
 .endfunc
 #endif /* defined (L_epilogue) */
+#endif /* !defined (__AVR_TINY__) */
 
 #ifdef L_exit
 	.section .fini9,"ax",@progbits
@@ -730,6 +746,7 @@ _cleanup:
 .endfunc
 #endif /* defined (L_cleanup) */
 
+#if !defined(__AVR_TINY__)
 #ifdef L_tablejump
 	.global __tablejump2__
 	.func	__tablejump2__
@@ -762,7 +779,9 @@ __tablejump__:
 #endif
 	.endfunc
 #endif /* defined (L_tablejump) */
+#endif
 
+#if !defined(__AVR_TINY__)
 #ifdef L_copy_data
 	.section .init4,"ax",@progbits
 	.global __do_copy_data
@@ -824,6 +843,7 @@ __do_copy_data:
 	brne	.L__do_copy_data_loop
 #endif /* !defined(__AVR_HAVE_ELPMX__) && !defined(__AVR_HAVE_ELPM__) */
 #endif /* L_copy_data */
+#endif
 
 /* __do_clear_bss is only necessary if there is anything in .bss section.  */
 
@@ -864,7 +884,12 @@ __do_global_ctors:
 	ldi	r20, hh8(__ctors_end)
 	rjmp	.L__do_global_ctors_start
 .L__do_global_ctors_loop:
+#if defined (__AVR_TINY__)
+	subi    r28, lo8(2)
+	sbci    r29, hi8(2)
+#else
 	sbiw	r28, 2
+#endif
 	sbc     r20, __zero_reg__
 	mov_h	r31, r29
 	mov_l	r30, r28
@@ -882,7 +907,12 @@ __do_global_ctors:
 	ldi	r29, hi8(__ctors_end)
 	rjmp	.L__do_global_ctors_start
 .L__do_global_ctors_loop:
+#if defined (__AVR_TINY__)
+    subi    r28, lo8(2)
+    sbci    r29, hi8(2)
+#else
 	sbiw	r28, 2
+#endif
 	mov_h	r31, r29
 	mov_l	r30, r28
 	XCALL	__tablejump__
@@ -905,7 +935,12 @@ __do_global_dtors:
 	ldi	r20, hh8(__dtors_start)
 	rjmp	.L__do_global_dtors_start
 .L__do_global_dtors_loop:
+#if defined (__AVR_TINY__)
+    subi    r28, lo8(2)
+    sbci    r29, hi8(2)
+#else
 	sbiw	r28, 2
+#endif
 	sbc     r20, __zero_reg__
 	mov_h	r31, r29
 	mov_l	r30, r28
@@ -926,7 +961,12 @@ __do_global_dtors:
 	mov_h	r31, r29
 	mov_l	r30, r28
 	XCALL	__tablejump__
+#if defined (__AVR_TINY__)
+	subi    r28, lo8(-2)
+	sbci    r29, hi8(-2)
+#else
 	adiw	r28, 2
+#endif
 .L__do_global_dtors_start:
 	cpi	r28, lo8(__dtors_end)
 	cpc	r29, r17
@@ -934,6 +974,7 @@ __do_global_dtors:
 #endif /* defined(__AVR_HAVE_RAMPZ__) */
 #endif /* L_dtors */
 
+#if !defined (__AVR_TINY__)
 #ifdef L_tablejump_elpm
 	.global __tablejump_elpm__
 	.func	__tablejump_elpm__
@@ -963,5 +1004,6 @@ __tablejump_elpm__:
 #endif /* defined (__AVR_HAVE_ELPM__) */
 	.endfunc
 #endif /* defined (L_tablejump_elpm) */
+#endif /* !defined (__AVR_TINY__) */
 
 #include "libgcc-fixed.S"
diff --git a/gcc/config/avr/predicates.md b/gcc/config/avr/predicates.md
index aca33d7..3ff85fd 100755
--- a/gcc/config/avr/predicates.md
+++ b/gcc/config/avr/predicates.md
@@ -45,21 +45,24 @@
 ;; Return true if OP is a valid address for lower half of I/O space.
 (define_predicate "low_io_address_operand"
   (and (match_code "const_int")
-       (if_then_else (match_test "AVR_XMEGA")
+       (if_then_else (ior (match_test "AVR_XMEGA")
+				          (match_test "AVR_TINY"))
                      (match_test "IN_RANGE((INTVAL (op)), 0x00, 0x1F)")
 	             (match_test "IN_RANGE((INTVAL (op)), 0x20, 0x3F)"))))
 
 ;; Return true if OP is a valid address for high half of I/O space.
 (define_predicate "high_io_address_operand"
   (and (match_code "const_int")
-       (if_then_else (match_test "AVR_XMEGA")
+       (if_then_else (ior (match_test "AVR_XMEGA")
+				          (match_test "AVR_TINY"))
                      (match_test "IN_RANGE((INTVAL (op)), 0x20, 0x3F)")
 	             (match_test "IN_RANGE((INTVAL (op)), 0x40, 0x5F)"))))
 
 ;; Return true if OP is a valid address of I/O space.
 (define_predicate "io_address_operand"
   (and (match_code "const_int")
-       (if_then_else (match_test "AVR_XMEGA")
+       (if_then_else (ior (match_test "AVR_XMEGA")
+				          (match_test "AVR_TINY"))
 		(match_test "IN_RANGE((INTVAL (op)), 0x0, (0x40 - GET_MODE_SIZE(mode)))")
 		(match_test "IN_RANGE((INTVAL (op)), 0x20, (0x60 - GET_MODE_SIZE(mode)))"))))
 
diff --git a/gcc/config/avr/t-avr b/gcc/config/avr/t-avr
index b068d3c..644195b 100644
--- a/gcc/config/avr/t-avr
+++ b/gcc/config/avr/t-avr
@@ -73,8 +73,8 @@ fp-bit.c: $(srcdir)/config/fp-bit.c $(srcdir)/config/avr/t-avr
 
 FPBIT = fp-bit.c
 
-MULTILIB_OPTIONS = mmcu=avr2/mmcu=avr25/mmcu=avr3/mmcu=avr31/mmcu=avr35/mmcu=avr4/mmcu=avr5/mmcu=avr51/mmcu=avr6/mmcu=avrxmega2/mmcu=avrxmega4/mmcu=avrxmega5/mmcu=avrxmega6/mmcu=avrxmega7
-MULTILIB_DIRNAMES = avr2 avr25 avr3 avr31 avr35 avr4 avr5 avr51 avr6 avrxmega2 avrxmega4 avrxmega5 avrxmega6 avrxmega7
+MULTILIB_OPTIONS = mmcu=avr2/mmcu=avr25/mmcu=avr3/mmcu=avr31/mmcu=avr35/mmcu=avr4/mmcu=avr5/mmcu=avr51/mmcu=avr6/mmcu=avrxmega2/mmcu=avrxmega4/mmcu=avrxmega5/mmcu=avrxmega6/mmcu=avrxmega7/mmcu=avrtiny10
+MULTILIB_DIRNAMES = avr2 avr25 avr3 avr31 avr35 avr4 avr5 avr51 avr6 avrxmega2 avrxmega4 avrxmega5 avrxmega6 avrxmega7 avrtiny10
 
 # The many avr2 matches are not listed here - this is the default.
 MULTILIB_MATCHES = \
@@ -244,7 +244,13 @@ MULTILIB_MATCHES = \
 	mmcu?avrxmega6=mmcu?atxmega256a3b \
 	mmcu?avrxmega6=mmcu?atxmega256d3 \
 	mmcu?avrxmega7=mmcu?atxmega128a1 \
-	mmcu?avrxmega7=mmcu?atxmega128a1u
+	mmcu?avrxmega7=mmcu?atxmega128a1u \
+	mmcu?avrtiny10=mmcu?attiny4 \
+	mmcu?avrtiny10=mmcu?attiny5 \
+	mmcu?avrtiny10=mmcu?attiny9 \
+	mmcu?avrtiny10=mmcu?attiny10 \
+	mmcu?avrtiny10=mmcu?attiny20 \
+	mmcu?avrtiny10=mmcu?attiny40
 
 MULTILIB_EXCEPTIONS =
 
-- 
1.6.0.4