path: root/binutils_patches/0006-Numerous-changes-and-bug-fixes.patch

From 3447c315a86e833246c70404af4b6f6946751b45 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=85ke=20Rehnman?= <ake_rehnman_at_gmail_com>
Date: Sat, 3 Mar 2018 10:54:22 +0100
Subject: [PATCH 6/10] Numerous changes and bug fixes
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Changed bfd address size to 32 bits
* Fixed reversed operands for mov insn in gas
* Removed fp support in gdb and added dwarf register mapping for sdcc
* Changed ld script template
* Fixed reversed operand for mov insn in disassembly

Signed-off-by: Åke Rehnman <ake_rehnman_at_gmail_com>
---
 bfd/cpu-stm8.c             |   3 +-
 gas/config/tc-stm8.c       |  34 ++-
 gdb/remote.c               |  22 +-
 gdb/stm8-tdep.c            | 535 ++++++++++++++++++++++-----------------------
 include/opcode/stm8.h      |   2 +
 ld/Makefile.in             |   2 +-
 ld/emulparams/elf32stm8.sh |   3 +-
 ld/scripttempl/elfstm8.sc  | 232 --------------------
 ld/scripttempl/stm8.sc     | 270 +++++++++++++++++++++++
 opcodes/stm8-dis.c         |  53 ++++-
 opcodes/stm8-opc.c         |   9 +-
 11 files changed, 630 insertions(+), 535 deletions(-)
 delete mode 100644 ld/scripttempl/elfstm8.sc
 create mode 100644 ld/scripttempl/stm8.sc

diff --git a/bfd/cpu-stm8.c b/bfd/cpu-stm8.c
index feb6cf805e..d858d0fd8e 100644
--- a/bfd/cpu-stm8.c
+++ b/bfd/cpu-stm8.c
@@ -25,7 +25,8 @@
 const bfd_arch_info_type bfd_stm8_arch =
 {
   8,                           /* bits per word */
-  24,                           /* bits per address */
+  32,                           /* bits per address */
+//  24,                           /* bits per address */
   8,                            /* bits per byte */
   bfd_arch_stm8,                /* architecture */
   bfd_mach_stm8,                /* machine */
diff --git a/gas/config/tc-stm8.c b/gas/config/tc-stm8.c
index 1fa4503ce2..38fa50722a 100644
--- a/gas/config/tc-stm8.c
+++ b/gas/config/tc-stm8.c
@@ -704,7 +704,7 @@ int read_arg(char *str, expressionS *exps)
 		expression(exps);
 		if (stm8_debug)
 			print_expr(exps);
-		exps->X_md=OP_OFF_X;
+		exps->X_md=OP_OFF_Y;
 		return 1;
 	}
 	//offset,SP
@@ -775,19 +775,29 @@ static
 void stm8_bfd_out(struct stm8_opcodes_s op, expressionS exp[], int count, char *frag)
 {
 	int i;
+	int arg = 0;
+	int dir = 1;
+	
+	/* if count is negative the arguments are reversed */
+	if (count < 0)
+	{
+		count = -count;
+		arg = count - 1;
+		dir = -1;
+	}
 
-	for(i = 0; i < count; i++)
+	for(i = 0; i < count; i++, arg += dir)
 	{
 		int where = frag - frag_now->fr_literal;
 
-		if (exp[i].X_op != O_illegal)
+		if (exp[arg].X_op != O_illegal)
 		{
-			switch(op.constraints[i])
+			switch(op.constraints[arg])
 			{
 			case ST8_EXTMEM:
 			case ST8_EXTOFF_X:
 			case ST8_EXTOFF_Y:
-				fix_new_exp(frag_now, where, 3, &exp[i], FALSE, BFD_RELOC_24);
+				fix_new_exp(frag_now, where, 3, &exp[arg], FALSE, BFD_RELOC_24);
 				bfd_put_bits(0xaaaaaaaa, frag, 24, true);
 				frag+=3;
 				break;
@@ -799,7 +809,7 @@ void stm8_bfd_out(struct stm8_opcodes_s op, expressionS exp[], int count, char *
 			case ST8_LONGOFF_X:
 			case ST8_WORD:
 			case ST8_LONGMEM:
-				fix_new_exp(frag_now, where, 2, &exp[i], FALSE, BFD_RELOC_16);
+				fix_new_exp(frag_now, where, 2, &exp[arg], FALSE, BFD_RELOC_16);
 				bfd_put_bits(0xaaaaaaaa, frag, 16, true);
 				frag+=2;
 				break;
@@ -811,17 +821,17 @@ void stm8_bfd_out(struct stm8_opcodes_s op, expressionS exp[], int count, char *
 			case ST8_SHORTOFF_SP:
 			case ST8_BYTE:
 			case ST8_SHORTMEM:
-				fix_new_exp(frag_now, where, 1, &exp[i], FALSE, BFD_RELOC_8);
+				fix_new_exp(frag_now, where, 1, &exp[arg], FALSE, BFD_RELOC_8);
 				bfd_put_bits(0xaaaaaaaa, frag, 8, true);
 				frag+=1;
 				break;
 			case ST8_PCREL:
-				fix_new_exp(frag_now, where, 1, &exp[i], TRUE, BFD_RELOC_8_PCREL);
+				fix_new_exp(frag_now, where, 1, &exp[arg], TRUE, BFD_RELOC_8_PCREL);
 				bfd_put_bits(0xaaaaaaaa, frag, 8, true);
 				frag+=1;
 				break;
 			case ST8_BIT_0:
-				fix_new_exp(frag_now, where-3, 1, &exp[i], FALSE, BFD_RELOC_STM8_BIT_FLD);
+				fix_new_exp(frag_now, where-3, 1, &exp[arg], FALSE, BFD_RELOC_STM8_BIT_FLD);
 				break;
 			default:
 				break;
@@ -986,6 +996,12 @@ md_assemble (char *str)
 			int opcode_length = stm8_opcode_size(opcode[i].bin_opcode);
 			bfd_put_bits(opcode[i].bin_opcode, frag, opcode_length * 8, true);
 			frag += opcode_length;
+			
+			/* mov insn operands are reversed */
+			if ((opcode[i].bin_opcode == 0x35) || (opcode[i].bin_opcode == 0x45) || (opcode[i].bin_opcode == 0x55))
+			{
+				count = -count;
+			}
 			stm8_bfd_out(opcode[i], exps, count, frag);
 			break;
 		}
diff --git a/gdb/remote.c b/gdb/remote.c
index 208bf4609b..0fb35a069c 100644
--- a/gdb/remote.c
+++ b/gdb/remote.c
@@ -9654,6 +9654,15 @@ extended_remote_create_inferior (struct target_ops *ops,
   if (extended_remote_supports_disable_randomization (ops))
     extended_remote_disable_randomization (disable_randomization);
 
+  //akre
+  if (remote_run_connect)
+  {
+	  ops->to_open("localhost:3333", from_tty);
+	  if (remote_run_load)
+		  generic_load (exec_file, from_tty);
+	  init_thread_list ();
+  }
+
   /* If startup-with-shell is on, we inform gdbserver to start the
      remote inferior using a shell.  */
   if (packet_support (PACKET_QStartupWithShell) != PACKET_DISABLE)
@@ -9672,17 +9681,6 @@ Remote replied unexpectedly while setting startup-with-shell: %s"),
 
   extended_remote_set_inferior_cwd (rs);
 
-  //akre
-  if (remote_run_connect)
-  {
-	  ops->to_open("localhost:3333", from_tty);
-	  if (remote_run_load)
-		  generic_load (exec_file, from_tty);
-	  init_thread_list ();
-	  run_worked = 0;
-  }
-  else
-  {
   /* Now restart the remote server.  */
   run_worked = extended_remote_run (args) != -1;
   if (!run_worked)
@@ -9697,7 +9695,7 @@ Remote replied unexpectedly while setting startup-with-shell: %s"),
       /* Fall back to "R".  */
       extended_remote_restart ();
     }
-  }
+
   if (!have_inferiors ())
     {
       /* Clean up from the last time we ran, before we mark the target
diff --git a/gdb/stm8-tdep.c b/gdb/stm8-tdep.c
index fd4b96c6c0..99276d5cf8 100644
--- a/gdb/stm8-tdep.c
+++ b/gdb/stm8-tdep.c
@@ -2,7 +2,7 @@
    Written by Ake Rehnman 2017-02-21,
    ake.rehnman (at) gmail dot com
 
-   Copyright (C) 1996-2016 Free Software Foundation, Inc.
+   Copyright (C) 1996-2018 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -44,19 +44,24 @@ enum stm8_regnum
   STM8_Y_REGNUM,
   STM8_SP_REGNUM,
   STM8_CC_REGNUM,
-  //pseudo register
-  STM8_FP_REGNUM
+  //pseudo registers
+  STM8_XH_REGNUM,
+  STM8_XL_REGNUM,
+  STM8_YH_REGNUM,
+  STM8_YL_REGNUM,
 };
 
-static const char *stm8_register_names[] =
+#define STM8_NUM_PSEUDOREGS 4
+
+enum stm8_producer
 {
-  "pc", "a",   "x",  "y",  "sp", "cc"
+  GCC_PRODUCER,
+  SDCC_PRODUCER
 };
 
-struct stm8_soft_reg
+static const char *stm8_register_names[] =
 {
-  const char *name;
-  CORE_ADDR   addr;
+  "pc", "a",   "x",  "y",  "sp", "cc"
 };
 
 unsigned int stm8_debug;
@@ -65,7 +70,13 @@ unsigned int stm8_debug;
 
 struct gdbarch_tdep
 {
-  struct stm8_soft_reg fp_reg;
+  enum stm8_producer producer;
+  /* Type for void.  */
+  struct type *void_type;
+  /* Type for a function returning void.  */
+  struct type *func_void_type;
+  /* Type for a pointer to a function.  Used for the type of PC.  */
+  struct type *pc_type;
 };
 
 enum insn_return_kind {
@@ -80,10 +91,19 @@ stm8_convert_register_p (struct gdbarch *gdbarch, int regnum,
 {
 	struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 
-	if ((regnum == STM8_FP_REGNUM) && (TYPE_LENGTH(type) > 2))
+	if ((regnum == STM8_SP_REGNUM) && (TYPE_LENGTH(type) > 2))
+	{
+		return 1;
+	}
+	if ((regnum == STM8_X_REGNUM) && (TYPE_LENGTH(type) > 2))
+	{
+		return 1;
+	}
+	if ((regnum == STM8_Y_REGNUM) && (TYPE_LENGTH(type) > 2))
 	{
 		return 1;
 	}
+
 	return 0;
 }
 
@@ -95,60 +115,43 @@ stm8_register_to_value (struct frame_info *frame, int regnum,
 		struct type *type, gdb_byte *to,
 		int *optimizedp, int *unavailablep)
 {
-	struct type *fpreg_type = register_type (get_frame_arch (frame),
-			STM8_FP_REGNUM);
-
-	/* We only support ptr values.  */
-	if ((TYPE_CODE (type) != TYPE_CODE_PTR) && (regnum != STM8_FP_REGNUM) && (TYPE_LENGTH(type) >= TYPE_LENGTH(fpreg_type)))
-	{
-		warning (_("Conversion failure in stm8_register_to_value: regnum = %d "), regnum);
-		*optimizedp = *unavailablep = 0;
-		return 0;
-	}
-
 	/* Convert to TYPE.  */
 
 	memset(to,0,TYPE_LENGTH(type));
 
-	if (!get_frame_register_bytes (frame, regnum, 0, TYPE_LENGTH (fpreg_type),
-			to+TYPE_LENGTH(type)-TYPE_LENGTH(fpreg_type), optimizedp, unavailablep))
+	if (!get_frame_register_bytes (frame, regnum, 0, 2,
+			to+TYPE_LENGTH(type)-2, optimizedp, unavailablep))
 		return 0;
 
 	*optimizedp = *unavailablep = 0;
 	return 1;
 }
 
-
-/* Look in the symbol table for the address of a pseudo register
-   in memory.  If we don't find it, pretend the register is not used
-   and not available.  */
-static void
-stm8_get_register_info (struct stm8_soft_reg *reg, const char *name)
+static stm8_producer
+stm8_get_producer()
 {
-	struct bound_minimal_symbol msymbol;
+  struct objfile *objfile;
+  struct compunit_symtab *cust;
 
-	msymbol = lookup_minimal_symbol (name, NULL, NULL);
-	if (msymbol.minsym)
-	{
-		reg->addr = BMSYMBOL_VALUE_ADDRESS (msymbol);
-		reg->name = xstrdup (name);
-	}
-	else
-	{
-		reg->name = 0;
-		reg->addr = 0;
-	}
+  if (current_program_space != NULL)
+  {
+    ALL_COMPUNITS(objfile, cust)
+    {
+      if (cust
+        && COMPUNIT_PRODUCER (cust) != NULL
+        && startswith (COMPUNIT_PRODUCER (cust), "SDCC"))
+      {
+        return SDCC_PRODUCER;
+      }
+    }
+  }
+  return GCC_PRODUCER;
 }
 
 static void
 stm8_initialize_soft_register_info(struct gdbarch_tdep *tdep)
 {
-	stm8_get_register_info(&tdep->fp_reg, "_fp_");
-	if ((tdep->fp_reg.name == 0) && (symfile_objfile))
-	{
-		warning (_("No frame soft register found in the symbol table (_fp_).\n"
-				"Stack backtrace will not work.\n"));
-	}
+  tdep->producer = stm8_get_producer();
 }
 
 static const char *
@@ -156,8 +159,21 @@ stm8_register_name (struct gdbarch *gdbarch, int regnum)
 {
 	if (regnum >= 0 && regnum < STM8_NUM_REGS)
 		return stm8_register_names[regnum];
-	if (regnum == STM8_FP_REGNUM)
-		return "fp";
+		
+	if (stm8_get_producer() == SDCC_PRODUCER)
+	{
+		switch (regnum)
+		{
+			case STM8_XH_REGNUM :
+				return "xh";
+			case STM8_XL_REGNUM :
+				return "xl";
+			case STM8_YH_REGNUM :
+				return "yh";
+			case STM8_YL_REGNUM :
+				return "yl";
+		}
+	}
 	return NULL;
 }
 
@@ -175,8 +191,6 @@ stm8_register_type (struct gdbarch *gdbarch, int regnum)
 	case STM8_X_REGNUM:
 	case STM8_Y_REGNUM:
 		return builtin_type (gdbarch)->builtin_uint16;
-	case STM8_FP_REGNUM:
-		return builtin_type (gdbarch)->builtin_uint16;
 	default:
 		return builtin_type (gdbarch)->builtin_uint8;
 	}
@@ -190,17 +204,43 @@ stm8_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
 	struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 	enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 	int regsize = 2;
+	gdb_byte tmp[4];
+	
 
 	switch (regnum)
 	{
-	case STM8_FP_REGNUM:
-		/* Fetch a soft register: translate into a memory read.  */
-		memset (buf, 0, regsize);
-		if (tdep->fp_reg.name)
+	case STM8_XH_REGNUM:
+		status = regcache_raw_read(regcache, STM8_X_REGNUM, tmp);
+		if (status == REG_VALID)
 		{
-			target_read_memory (tdep->fp_reg.addr, buf, 2);
+			buf[0] = tmp[0];
 		}
-		return REG_VALID;
+		return status;
+
+	case STM8_XL_REGNUM:
+		status = regcache_raw_read(regcache, STM8_X_REGNUM, tmp);
+		if (status == REG_VALID)
+		{
+			buf[0] = tmp[1];
+		}
+		return status;
+
+	case STM8_YH_REGNUM:
+		status = regcache_raw_read(regcache, STM8_Y_REGNUM, tmp);
+		if (status == REG_VALID)
+		{
+			buf[0] = tmp[0];
+		}
+		return status;
+
+	case STM8_YL_REGNUM:
+		status = regcache_raw_read(regcache, STM8_Y_REGNUM, tmp);
+		if (status == REG_VALID)
+		{
+			buf[0] = tmp[1];
+		}
+	 	return status;
+
 	default:
 		internal_error (__FILE__, __LINE__, _("invalid regnum"));
 		return REG_UNAVAILABLE;
@@ -215,16 +255,47 @@ stm8_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
 	enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 	struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 	const int regsize = 2;
+	gdb_byte tmp[4];
 
 	switch (regnum)
 	{
-	case STM8_FP_REGNUM:
-		/* Store a soft register: translate into a memory write.  */
-		if (tdep->fp_reg.name)
+		
+	case STM8_XH_REGNUM:
+		status = regcache_raw_read(regcache, STM8_X_REGNUM, tmp);
+		if (status == REG_VALID)
 		{
-			target_write_memory (tdep->fp_reg.addr, buf, 2);
-		}
-		return;
+		  tmp[0] = buf[0];
+		  regcache_raw_write (regcache, STM8_X_REGNUM, tmp);
+	  }
+	  return;
+
+	case STM8_XL_REGNUM:
+		status = regcache_raw_read(regcache, STM8_X_REGNUM, tmp);
+		if (status == REG_VALID)
+		{
+		  tmp[1] = buf[0];
+		  regcache_raw_write (regcache, STM8_X_REGNUM, tmp);
+	  }
+	  return;
+
+	case STM8_YH_REGNUM:
+		status = regcache_raw_read(regcache, STM8_Y_REGNUM, tmp);
+		if (status == REG_VALID)
+		{
+		  tmp[0] = buf[0];
+		  regcache_raw_write (regcache, STM8_Y_REGNUM, tmp);
+	  }
+	  return;
+
+	case STM8_YL_REGNUM:
+		status = regcache_raw_read(regcache, STM8_Y_REGNUM, tmp);
+		if (status == REG_VALID)
+		{
+		  tmp[1] = buf[0];
+		  regcache_raw_write (regcache, STM8_Y_REGNUM, tmp);
+	  }
+	  return;
+		
 	default:
 		internal_error (__FILE__, __LINE__, _("invalid regnum"));
 		return;
@@ -271,7 +342,6 @@ stm8_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
 }
 
 /* Implement the breakpoint_kind_from_pc gdbarch method.  */
-#if 0
 static int
 stm8_breakpoint_kind_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr)
 {
@@ -298,23 +368,55 @@ stm8_sw_breakpoint_from_kind (struct gdbarch *gdbarch, int kind, int *size)
 	return stm8_breakpoint;
 }
 
-#endif
+static int dwarf2_to_reg_map_sdcc[] =
+{ 
+  STM8_A_REGNUM,  //a
+  STM8_XL_REGNUM,  //xl
+  STM8_XH_REGNUM,  //xh
+  STM8_YL_REGNUM,  //yl
+  STM8_YH_REGNUM,  //yh
+  STM8_CC_REGNUM,  //cc
+  STM8_X_REGNUM,  //x
+  STM8_Y_REGNUM,  //y
+  STM8_SP_REGNUM,  //sp
+  STM8_PC_REGNUM,  //pc
+  -1
+};
 
-static int dwarf2_to_reg_map[6] =
-{ 0  /* r0  */,   1  /* r1  */,   2  /* r2  */,   3  /* r3  */,  /*  0- 3 */
-		4  /* r4  */,   5  /* r5  */
+static int dwarf2_to_reg_map_gcc[] =
+{ STM8_A_REGNUM,  //a
+  STM8_X_REGNUM,  //x
+  STM8_Y_REGNUM,  //y
+  STM8_SP_REGNUM, //sp
+  -1
 };
 
 static int
 stm8_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int reg)
 {
-	if (stm8_debug)
-		fprintf_unfiltered (gdb_stdlog, "stm8_dwarf2_reg_to_regnum called\n");
-	if (reg >= 0 && reg < sizeof (dwarf2_to_reg_map))
-		return dwarf2_to_reg_map[reg];
-	if (reg == 31)
-		return STM8_FP_REGNUM;
-	return -1;
+  int ret = -1;
+  
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+  static int * t;
+  
+  if (stm8_get_producer() == SDCC_PRODUCER)
+    t = dwarf2_to_reg_map_sdcc;
+  else
+    t = dwarf2_to_reg_map_gcc;
+
+  for (int i = 0; (t[i] > 0) && (i < 32); i++)
+  {
+	if (i == reg)
+	{
+		ret = t[i];
+		break;
+	}
+  }
+
+  if ((stm8_debug>1) && (ret>=0))
+	fprintf_unfiltered (gdb_stdlog, "stm8_dwarf2_reg_to_regnum called reg=%d ret=%d\n",reg,t[reg]);
+
+	return ret;
 }
 
 static void
@@ -333,7 +435,10 @@ stm8_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 
 	struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 	frame_unwind_register (next_frame, STM8_PC_REGNUM, buf);
-	pc = extract_typed_address (buf, builtin_type (gdbarch)->builtin_func_ptr);
+	if (frame_relative_level(next_frame) < 0)
+		pc = extract_typed_address (buf, builtin_type (gdbarch)->builtin_func_ptr);
+	else
+		pc = extract_typed_address (buf, tdep->pc_type);
 	if (stm8_debug)
 		fprintf_unfiltered (gdb_stdlog, "stm8_unwind_pc called: pc=%8.8lx\n", (unsigned long)pc);
 	return pc;
@@ -351,58 +456,6 @@ stm8_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
 	return sp;
 }
 
-#if 0
-static struct value *
-stm8_dwarf2_prev_register (struct frame_info *this_frame,
-		void **this_cache, int regnum)
-{
-	CORE_ADDR pc;
-
-	switch (regnum)
-	{
-	    case STM8_PC_REGNUM:
-	      pc = frame_unwind_register_unsigned (this_frame, AARCH64_PC_REGNUM);
-	      return frame_unwind_got_constant (this_frame, regnum, lr);
-
-	default:
-		internal_error (__FILE__, __LINE__,
-				_("Unexpected register %d"), regnum);
-	}
-}
-
-static void
-stm8_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
-		struct dwarf2_frame_state_reg *reg,
-		struct frame_info *this_frame)
-{
-	switch (regnum)
-	{
-	case STM8_PC_REGNUM:
-		reg->how = DWARF2_FRAME_REG_FN;
-		reg->loc.fn = stm8_dwarf2_prev_register;
-		break;
-	case STM8_SP_REGNUM:
-		reg->how = DWARF2_FRAME_REG_CFA;
-		break;
-	}
-}
-#endif
-
-/* Assuming THIS_FRAME is a dummy, return the frame ID of that
-   dummy frame.  The frame ID's base needs to match the TOS value
-   saved by save_dummy_frame_tos(), and the PC match the dummy frame's
-   breakpoint.  */
-
-static struct frame_id
-stm8_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
-{
-	fprintf_unfiltered (gdb_stdlog, "stm8_dummy_id called\n");
-
-	return frame_id_build
-			(get_frame_register_signed (this_frame, STM8_SP_REGNUM),
-					get_frame_pc (this_frame));
-}
-
 
 /* Allocate and initialize a frame cache.  */
 
@@ -471,7 +524,6 @@ stm8_analyze_prologue (struct gdbarch *gdbarch, CORE_ADDR pc,
 
 	/* Initialize info about frame.  */
 	cache->framesize = 0;
-	cache->fp_regnum = STM8_FP_REGNUM;
 	cache->frameless_p = 1;
 	cache->stackadj = 0;
 
@@ -505,7 +557,7 @@ stm8_analyze_prologue (struct gdbarch *gdbarch, CORE_ADDR pc,
 	}
 
 	/* Start at beginning of function and analyze until we get to the
-     current pc, or the end of the function, whichever is first.  */
+	current pc, or the end of the function, whichever is first.  */
 	stop = (current_pc < func_end ? current_pc : func_end);
 
 	if (stm8_debug)
@@ -585,6 +637,7 @@ stm8_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc)
 
 	struct symtab_and_line sal;
 	CORE_ADDR func_start, func_end, ostart_pc;
+	CORE_ADDR post_prologue_pc;
 	struct stm8_frame_cache cache;
 
 	/* This is the preferred method, find the end of the prologue by
@@ -593,18 +646,23 @@ stm8_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc)
      Always analyze the prologue.  */
 	if (find_pc_partial_function (start_pc, NULL, &func_start, &func_end))
 	{
-		sal = find_pc_line (func_start, 0);
+		post_prologue_pc = skip_prologue_using_sal (gdbarch, func_start);
 
-		if (sal.end < func_end
-				&& start_pc <= sal.end)
-			start_pc = sal.end;
+		if (stm8_debug)
+			fprintf_unfiltered (gdb_stdlog, "stm8_skip_prologue: post_prologue_pc=%8.8lx\n",
+				(unsigned long)post_prologue_pc);
+		
+		if (post_prologue_pc != 0)
+			return std::max (start_pc, post_prologue_pc);
 	}
 
 	ostart_pc = stm8_analyze_prologue (gdbarch, func_start, 0xffffffffUL,
 			&cache);
 
 	if (stm8_debug)
-		fprintf_unfiltered (gdb_stdlog, "stm8_skip_prologue: start_pc=%8.8lx ostart_pc=%8.8lx\n", (unsigned long)start_pc, (unsigned long)ostart_pc);
+		fprintf_unfiltered (gdb_stdlog, "stm8_skip_prologue: start_pc=%8.8lx ostart_pc=%8.8lx func_start=%8.8lx func_end=%8.8lx sal.end=%8.8lx\n", 
+		(unsigned long)start_pc, (unsigned long)ostart_pc, 
+		(unsigned long)func_start, (unsigned long)func_end, (unsigned long)sal.end);
 
 	if (ostart_pc > start_pc)
 		return ostart_pc;
@@ -632,7 +690,7 @@ stm8_frame_cache (struct frame_info *next_frame, void **this_cache)
 
 	struct stm8_frame_cache *cache;
 	struct gdbarch *gdbarch = get_frame_arch (next_frame);
-	CORE_ADDR start_pc, current_pc, current_sp, fp;
+	CORE_ADDR start_pc, current_pc, current_sp;
 	int retsize;
 
 	if (*this_cache)
@@ -655,22 +713,9 @@ stm8_frame_cache (struct frame_info *next_frame, void **this_cache)
 		stm8_analyze_prologue (gdbarch, start_pc, current_pc,
 				(struct stm8_frame_cache *) *this_cache);
 
-	/* get our fp by unwinding it from the next frame
-	 * if we don't have a fp we use sp instead but if there
-	 * are arguments on the stack unwinding will be
-	 * unpredictable.
-	 */
-	//fp = frame_unwind_register_unsigned (next_frame, cache->fp_regnum);
-	fp = get_frame_register_unsigned (next_frame, cache->fp_regnum);
-	if (fp == 0)
-	{
-		cache->base = 0;
-		cache->frameless_p = 1;
-		//return (struct stm8_frame_cache *) (*this_cache);
-	}
-
 	switch (cache->return_kind)
 	{
+	default:
 	case RETURN_RET:
 		retsize = 2;
 		break;
@@ -682,61 +727,33 @@ stm8_frame_cache (struct frame_info *next_frame, void **this_cache)
 		break;
 	}
 
-	if (cache->frameless_p)
-	{
-		cache->base = current_sp + cache->framesize;
-		if (cache->return_kind == RETURN_IRET)
-			cache->saved_regs[STM8_PC_REGNUM].addr = cache->base + 1 + 6;
-		else
-			cache->saved_regs[STM8_PC_REGNUM].addr = cache->base + 1;
-		trad_frame_set_value (cache->saved_regs,
-				STM8_SP_REGNUM,
-				cache->base+retsize);
-	}
+	cache->base = current_sp;
+	if (cache->return_kind == RETURN_IRET)
+		cache->saved_regs[STM8_PC_REGNUM].addr = cache->base + 1 + 6;
 	else
-	{
-		/* fp points to our base */
-		cache->base = fp;
-		if (cache->return_kind == RETURN_IRET)
-			cache->saved_regs[STM8_PC_REGNUM].addr = cache->base + 1 + 2 + 6;
-		else
-			cache->saved_regs[STM8_PC_REGNUM].addr = cache->base + 1 + 2;
-		cache->saved_regs[STM8_FP_REGNUM].addr = fp + 1;
-		trad_frame_set_value (cache->saved_regs,
-				STM8_SP_REGNUM,
-				cache->base+retsize+2);
-	}
-
+		cache->saved_regs[STM8_PC_REGNUM].addr = cache->base + 1;
+	trad_frame_set_value (cache->saved_regs,
+			STM8_SP_REGNUM,
+			cache->base+retsize);
 
 	if (stm8_debug)
 	{
-		fprintf_unfiltered (gdb_stdlog, "stm8_frame_cache: (next_frame=%p) base=%4.4lx curr_pc=%4.4lx curr_sp=%4.4lx fp_regnum=%d fp=%4.4lx framesize=%4.4x stackadj=%4.4x retsize=%d\n",
-				next_frame, (unsigned long)cache->base, (unsigned long)current_pc, (unsigned long)current_sp, cache->fp_regnum, (unsigned long)fp, cache->framesize, cache->stackadj, retsize);
+		fprintf_unfiltered (gdb_stdlog, "stm8_frame_cache: (next_frame=%p) base=%4.4lx curr_pc=%4.4lx curr_sp=%4.4lx framesize=%4.4x stackadj=%4.4x retsize=%d\n",
+				next_frame, (unsigned long)cache->base, (unsigned long)current_pc, (unsigned long)current_sp, cache->framesize, cache->stackadj, retsize);
 
 		CORE_ADDR frame_pc;
 		CORE_ADDR frame_sp;
-		CORE_ADDR frame_fp;
 		frame_pc = value_as_long(trad_frame_get_prev_register (next_frame, cache->saved_regs, STM8_PC_REGNUM));
 		frame_sp =  value_as_long(trad_frame_get_prev_register (next_frame, cache->saved_regs, STM8_SP_REGNUM));
 
-		// this is stupid, trad_frame_get_prev_register can't get a
-		// register value unless we have a valid frame id
-		// hopefully this will get resolved in the future :)
-		if (cache->saved_regs[STM8_FP_REGNUM].addr > 0)
-			frame_fp = value_as_long(trad_frame_get_prev_register (next_frame, cache->saved_regs, STM8_FP_REGNUM));
-		else
-			frame_fp = fp;
-
 		frame_pc = frame_pc >> 16;
 		fprintf_unfiltered (gdb_stdlog, "stm8_frame_cache: (next_frame=%p) pc=%8.8lx *pc=%8.8lx\n", next_frame, (unsigned long)cache->saved_regs[STM8_PC_REGNUM].addr, (unsigned long)frame_pc);
 		fprintf_unfiltered (gdb_stdlog, "stm8_frame_cache: (next_frame=%p) sp=%8.8lx *sp=%8.8lx\n", next_frame, (unsigned long)cache->saved_regs[STM8_SP_REGNUM].addr, (unsigned long)frame_sp);
-		fprintf_unfiltered (gdb_stdlog, "stm8_frame_cache: (next_frame=%p) fp=%8.8lx *fp=%8.8lx\n", next_frame, (unsigned long)cache->saved_regs[STM8_FP_REGNUM].addr, (unsigned long)frame_fp);
 	}
 
 	return (struct stm8_frame_cache *) (*this_cache);
 }
 
-
 /* Given a GDB frame, determine the address of the calling function's
    frame.  This will be used to create a new GDB frame struct.  */
 static void
@@ -771,22 +788,6 @@ stm8_frame_prev_register (struct frame_info *this_frame,
 
 	value = trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
 
-	/* Take into account the STM8 specific call.
-	 * Different lengths if it is CALL or CALLF  */
-	if (regnum == STM8_PC_REGNUM)
-	{
-		CORE_ADDR pc = value_as_long (value);
-		if (info->return_kind == RETURN_RET)
-			pc >>= 16;
-		else
-			pc >>= 8;
-
-		release_value (value);
-		value_free (value);
-
-		value = frame_unwind_got_constant (this_frame, regnum, pc);
-	}
-
 	if (stm8_debug)
 		fprintf_unfiltered (gdb_stdlog, "stm8_frame_prev_register: regnum(%d)=%8.8lx\n", regnum, (unsigned long)value_as_long(value));
 
@@ -876,53 +877,53 @@ static const struct frame_unwind stm8_frame_unwind = {
 		default_frame_sniffer
 };
 
-static CORE_ADDR
-stm8_frame_base_address (struct frame_info *next_frame,
-		void **this_cache)
-{
-	struct stm8_frame_cache *cache =
-			stm8_frame_cache (next_frame, this_cache);
-
-	if (stm8_debug)
-		fprintf_unfiltered (gdb_stdlog, "stm8_frame_base_address: fb=%8.8lx\n", (unsigned long)cache->base);
-
-	return cache->base;
-}
-
-static CORE_ADDR
-stm8_frame_args_address (struct frame_info *this_frame, void **this_cache)
-{
-	CORE_ADDR addr;
-	struct stm8_frame_cache *info
-	= stm8_frame_cache (this_frame, this_cache);
-
-	addr = info->base;
-	if (info->return_kind == RETURN_IRET)
-		addr += 12; //2 bytes fp + 9 bytes regs + 1
-	else if (info->return_kind == RETURN_RETF)
-		addr += 6; //2 bytes fp + 3 bytes pc + 1
-	else
-		addr += 5; //2 bytes fp + 2 bytes pc + 1
-
-	if (stm8_debug)
-		fprintf_unfiltered (gdb_stdlog, "stm8_frame_args_address: addr = %8.8lx\n", (unsigned long)addr);
-
-	return addr;
-}
-
-static const struct frame_base stm8_frame_base =
-{
-		&stm8_frame_unwind,
-		stm8_frame_base_address,
-		stm8_frame_base_address,
-		stm8_frame_args_address
-};
-
-static const struct frame_base *
-stm8_frame_base_sniffer (struct frame_info *this_frame)
-{
-	return &stm8_frame_base;
-}
+//static CORE_ADDR
+//stm8_frame_base_address (struct frame_info *next_frame,
+//		void **this_cache)
+//{
+//	struct stm8_frame_cache *cache =
+//			stm8_frame_cache (next_frame, this_cache);
+//
+//	if (stm8_debug)
+//		fprintf_unfiltered (gdb_stdlog, "stm8_frame_base_address: fb=%8.8lx\n", (unsigned long)cache->base);
+//
+//	return cache->base;
+//}
+
+//static CORE_ADDR
+//stm8_frame_args_address (struct frame_info *this_frame, void **this_cache)
+//{
+//	CORE_ADDR addr;
+//	struct stm8_frame_cache *info
+//	= stm8_frame_cache (this_frame, this_cache);
+//
+//	addr = info->base;
+//	if (info->return_kind == RETURN_IRET)
+//		addr += 12; //2 bytes fp + 9 bytes regs + 1
+//	else if (info->return_kind == RETURN_RETF)
+//		addr += 6; //2 bytes fp + 3 bytes pc + 1
+//	else
+//		addr += 5; //2 bytes fp + 2 bytes pc + 1
+//
+//	if (stm8_debug)
+//		fprintf_unfiltered (gdb_stdlog, "stm8_frame_args_address: addr = %8.8lx\n", (unsigned long)addr);
+//
+//	return addr;
+//}
+
+//static const struct frame_base stm8_frame_base =
+//{
+//		&stm8_frame_unwind,
+//		stm8_frame_base_address,
+//		stm8_frame_base_address,
+//		stm8_frame_args_address
+//};
+//
+//static const struct frame_base *
+//stm8_frame_base_sniffer (struct frame_info *this_frame)
+//{
+//	return &stm8_frame_base;
+//}
 
 struct target_desc *tdesc_stm8;
 static void
@@ -937,7 +938,7 @@ initialize_tdesc_stm8 (void)
 	tdesc_create_reg (feature, "x", 2, 1, "general", 16, "uint16");
 	tdesc_create_reg (feature, "y", 3, 1, "general", 16, "uint16");
 	tdesc_create_reg (feature, "sp", 4, 1, "general", 16, "uint16");
-	tdesc_create_reg (feature, "cc", 5, 1, "general", 8, "uint16");
+	tdesc_create_reg (feature, "cc", 5, 1, "general", 8, "uint8");
 
 	tdesc_stm8 = result;
 }
@@ -952,7 +953,7 @@ stm8_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   struct gdbarch_tdep *tdep;
   struct gdbarch_list *best_arch;
   struct tdesc_arch_data *tdesc_data = NULL;
-  const struct target_desc *tdesc = info.target_desc;
+  const struct target_desc *tdesc = info.target_desc = 0; //override target desc if any
 
   /* If there is already a candidate, use it.  */
   arches = gdbarch_list_lookup_by_info (arches, &info);
@@ -965,9 +966,6 @@ stm8_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   if (tdesc == NULL)
     tdesc = tdesc_stm8;
 
-  //override target registers... /ARE
-   tdesc = tdesc_stm8;
-
   /* Check any target description for validity.  */
   if (tdesc_has_registers (tdesc))
     {
@@ -1005,7 +1003,7 @@ stm8_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_tdesc_pseudo_register_type (gdbarch, stm8_register_type);
   set_tdesc_pseudo_register_name (gdbarch, stm8_register_name);
 
-  set_gdbarch_num_pseudo_regs (gdbarch, 1);
+  set_gdbarch_num_pseudo_regs (gdbarch, STM8_NUM_PSEUDOREGS);
   set_gdbarch_pseudo_register_read (gdbarch, stm8_pseudo_register_read);
   set_gdbarch_pseudo_register_write (gdbarch, stm8_pseudo_register_write);
 
@@ -1033,10 +1031,9 @@ stm8_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   /* Stack grows downward.  */
   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
 
-#if 0
   set_gdbarch_breakpoint_kind_from_pc (gdbarch, stm8_breakpoint_kind_from_pc);
   set_gdbarch_sw_breakpoint_from_kind (gdbarch,  stm8_sw_breakpoint_from_kind);
-#endif
+
   set_gdbarch_breakpoint_from_pc (gdbarch, stm8_breakpoint_from_pc);
 
   //set_gdbarch_frame_args_skip (gdbarch, 8);
@@ -1047,9 +1044,9 @@ stm8_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 
   set_gdbarch_unwind_pc (gdbarch, stm8_unwind_pc);
   set_gdbarch_unwind_sp (gdbarch, stm8_unwind_sp);
-  set_gdbarch_dummy_id (gdbarch, stm8_dummy_id);
+  ////set_gdbarch_dummy_id (gdbarch, stm8_dummy_id);
 
-  frame_base_set_default (gdbarch, &stm8_frame_base);
+  ////frame_base_set_default (gdbarch, &stm8_frame_base);
 
   /* Hook in ABI-specific overrides, if they have been registered.  */
   //gdbarch_init_osabi (info, gdbarch);
@@ -1060,14 +1057,16 @@ stm8_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   dwarf2_append_unwinders (gdbarch);
   frame_unwind_append_unwinder (gdbarch, &stm8_frame_unwind);
   frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
-  frame_base_append_sniffer (gdbarch, stm8_frame_base_sniffer);
+  ////frame_base_append_sniffer (gdbarch, stm8_frame_base_sniffer);
   
 //  /* Create a type for PC.  We can't use builtin types here, as they may not
 //     be defined.  */
-//  tdep->void_type = arch_type (gdbarch, TYPE_CODE_VOID, 1, "void");
-//  tdep->func_void_type = make_function_type (tdep->void_type, NULL);
-//  tdep->pc_type = arch_pointer_type (gdbarch, 4 * TARGET_CHAR_BIT, NULL,
-//				     tdep->func_void_type);
+  tdep->void_type = arch_type (gdbarch, TYPE_CODE_VOID, TARGET_CHAR_BIT, "void");
+  tdep->func_void_type = make_function_type (tdep->void_type, NULL);
+  tdep->pc_type = arch_type (gdbarch, TYPE_CODE_PTR, 2*TARGET_CHAR_BIT, NULL);
+  TYPE_TARGET_TYPE (tdep->pc_type) = tdep->func_void_type;
+  TYPE_UNSIGNED (tdep->pc_type) = 1;
+
 //
 //  set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
 //  set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
@@ -1089,9 +1088,9 @@ stm8_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 //
 //  set_gdbarch_dwarf2_reg_to_regnum (gdbarch, stm8_dwarf_reg_to_regnum);
 //
-//  set_gdbarch_address_to_pointer (gdbarch, avr_address_to_pointer);
-//  set_gdbarch_pointer_to_address (gdbarch, avr_pointer_to_address);
-//  set_gdbarch_integer_to_address (gdbarch, avr_integer_to_address);
+//  set_gdbarch_address_to_pointer (gdbarch, stm8_address_to_pointer);
+//  set_gdbarch_pointer_to_address (gdbarch, stm8_pointer_to_address);
+//  set_gdbarch_integer_to_address (gdbarch, stm8_integer_to_address);
 //
 //  frame_base_set_default (gdbarch, &stm8_frame_base);
 //
diff --git a/include/opcode/stm8.h b/include/opcode/stm8.h
index a40ff0aaaa..d131527d86 100644
--- a/include/opcode/stm8.h
+++ b/include/opcode/stm8.h
@@ -79,4 +79,6 @@ extern int stm8_compute_insn_size(struct stm8_opcodes_s opcode);
 
 extern unsigned int stm8_opcode_size(unsigned int number);
 
+int stm8_num_opcode_operands(struct stm8_opcodes_s opcode);
+
 #endif /* _STM8_H_ */
diff --git a/ld/Makefile.in b/ld/Makefile.in
index a73392c0d6..4d64b3c75c 100644
--- a/ld/Makefile.in
+++ b/ld/Makefile.in
@@ -3661,7 +3661,7 @@ eshlelf64_nbsd.c: $(srcdir)/emulparams/shlelf64_nbsd.sh \
   $(ELF_DEPS) $(srcdir)/scripttempl/elf.sc ${GEN_DEPENDS}
 
 eelf32stm8.c: $(srcdir)/emulparams/elf32stm8.sh \
-  $(ELF_DEPS) $(srcdir)/scripttempl/elfstm8.sc ${GEN_DEPENDS}
+  $(ELF_DEPS) $(srcdir)/scripttempl/stm8.sc ${GEN_DEPENDS}
 
 check-DEJAGNU: site.exp
 	srcroot=`cd $(srcdir) && pwd`; export srcroot; \
diff --git a/ld/emulparams/elf32stm8.sh b/ld/emulparams/elf32stm8.sh
index c37c9e51da..960ca3885f 100644
--- a/ld/emulparams/elf32stm8.sh
+++ b/ld/emulparams/elf32stm8.sh
@@ -1,6 +1,7 @@
 ARCH=stm8
 MACHINE=stm8
-SCRIPT_NAME=elfstm8
+SCRIPT_NAME=stm8
+#SCRIPT_NAME=elfstm8
 OUTPUT_FORMAT="elf32-stm8"
 MAXPAGESIZE=1
 EMBEDDED=yes
diff --git a/ld/scripttempl/elfstm8.sc b/ld/scripttempl/elfstm8.sc
deleted file mode 100644
index 0ce6b56741..0000000000
--- a/ld/scripttempl/elfstm8.sc
+++ /dev/null
@@ -1,232 +0,0 @@
-# Adapted from mips.sc
-#
-# Copyright (C) 2014-2016 Free Software Foundation, Inc.
-# 
-# Copying and distribution of this file, with or without modification,
-# are permitted in any medium without royalty provided the copyright
-# notice and this notice are preserved.
-#
-# These variables may be overridden by the emulation file.  The
-# defaults are appropriate for a DECstation running Ultrix.
-
-test -z "$ENTRY" && ENTRY=_start
-
-#test -z "$TEXT_START_ADDR" && TEXT_START_ADDR="0x0"
-
-CTOR=".ctors ${CONSTRUCTING-0} : 
-  {
-    ${CONSTRUCTING+${CTOR_START}}
-    /* gcc uses crtbegin.o to find the start of
-       the constructors, so we make sure it is
-       first.  Because this is a wildcard, it
-       doesn't matter if the user does not
-       actually link against crtbegin.o; the
-       linker won't look for a file to match a
-       wildcard.  The wildcard also means that it
-       doesn't matter which directory crtbegin.o
-       is in.  */
-
-    KEEP (*crtbegin.o(.ctors))
-
-    /* We don't want to include the .ctor section from
-       from the crtend.o file until after the sorted ctors.
-       The .ctor section from the crtend file contains the
-       end of ctors marker and it must be last */
-
-    KEEP (*(EXCLUDE_FILE (*crtend.o) .ctors))
-    KEEP (*(SORT(.ctors.*)))
-    KEEP (*(.ctors))
-    ${CONSTRUCTING+${CTOR_END}}
-  }"
-
-DTOR=" .dtors       ${CONSTRUCTING-0} :
-  {
-    ${CONSTRUCTING+${DTOR_START}}
-    KEEP (*crtbegin.o(.dtors))
-    KEEP (*(EXCLUDE_FILE (*crtend.o) .dtors))
-    KEEP (*(SORT(.dtors.*)))
-    KEEP (*(.dtors))
-    ${CONSTRUCTING+${DTOR_END}}
-  }"
-
-cat <<EOF
-/* Copyright (C) 2014-2016 Free Software Foundation, Inc.
-
-   Copying and distribution of this script, with or without modification,
-   are permitted in any medium without royalty provided the copyright
-   notice and this notice are preserved.  */
-
-OUTPUT_FORMAT("${OUTPUT_FORMAT}", "${BIG_OUTPUT_FORMAT}",
-	      "${LITTLE_OUTPUT_FORMAT}")
-/*${LIB_SEARCH_DIRS}*/
-${RELOCATING+${LIB_SEARCH_DIRS}}
-
-${RELOCATING+ENTRY (${ENTRY})}
-
-_TEXT_START_ADDR = DEFINED(_TEXT_START_ADDR) ? _TEXT_START_ADDR : 0x50;		
-_HEAP_SIZE = DEFINED(_HEAP_SIZE) ? _HEAP_SIZE : 0x0;
-_STACK_SIZE = DEFINED(_STACK_SIZE) ? _STACK_SIZE : 0x400;
-
-SECTIONS
-{
-  .vectors.reset 0x8000 : { KEEP (*(.vectors.reset)) } = 0
-
-  ${RELOCATING+. = _TEXT_START_ADDR;}
-
-  ${RELOCATING+ _ftext  =  .;}
-  .text : {
-    ${RELOCATING+*(.text)}
-    ${RELOCATING+*(.text.*)}
-    ${RELOCATING+*(.gnu.linkonce.t.*)}
-  }
-  ${RELOCATING+ _etext  =  .;}
-
-  .init : { KEEP (*(.init))	} =0
-  .fini : { KEEP (*(.fini))	} =0
-
-  ${RELOCATING+PROVIDE (__CTOR_LIST__ = .);}
-  ${RELOCATING+PROVIDE (___CTOR_LIST__ = .);}
-  ${RELOCATING+${CTOR}}
-  ${RELOCATING+PROVIDE (__CTOR_END__ = .);}
-  ${RELOCATING+PROVIDE (___CTOR_END__ = .);}
-
-  ${RELOCATING+PROVIDE (__DTOR_LIST__ = .);}
-  ${RELOCATING+PROVIDE (___DTOR_LIST__ = .);}
-  ${RELOCATING+${DTOR}}
-  ${RELOCATING+PROVIDE (__DTOR_END__ = .);}
-  ${RELOCATING+PROVIDE (___DTOR_END__ = .);}
-
-  ${RELOCATING+ . = ALIGN(4);}
-   ${RELOCATING+ _frodata = . ;}
-  .rodata : {
-    ${RELOCATING+*(.rodata)}
-    ${RELOCATING+*(.rodata.*)}
-    ${RELOCATING+*(.gnu.linkonce.r.*)}
-    ${CONSTRUCTING+CONSTRUCTORS}; /* Is this needed? */
-  }
-  ${RELOCATING+ _erodata = .;}
-
-  /* Alignments by 8 to ensure that _SDA2_BASE_ on a word boundary */
-  /* Note that .sdata2 and .sbss2 must be contiguous */
-  ${RELOCATING+. = ALIGN(8);}
-  ${RELOCATING+ _ssrw = .;}
-  .sdata2 : {
-    ${RELOCATING+*(.sdata2)}
-    ${RELOCATING+*(.sdata2.*)}
-    ${RELOCATING+*(.gnu.linkonce.s2.*)}
-  }
-  ${RELOCATING+. = ALIGN(4);}
-  .sbss2 : {
-    ${RELOCATING+PROVIDE (__sbss2_start = .);}	
-    ${RELOCATING+*(.sbss2)}
-    ${RELOCATING+*(.sbss2.*)}
-    ${RELOCATING+*(.gnu.linkonce.sb2.*)}
-    ${RELOCATING+PROVIDE (__sbss2_end = .);}
-  }
-  ${RELOCATING+. = ALIGN(8);}
-  ${RELOCATING+ _essrw = .;}
-  ${RELOCATING+ _ssrw_size = _essrw - _ssrw;}
-  ${RELOCATING+ PROVIDE (_SDA2_BASE_ = _ssrw + (_ssrw_size / 2 ));}
-
-  ${RELOCATING+ . = ALIGN(4);}
-  ${RELOCATING+ _fdata = .;}
-  .data : {
-    ${RELOCATING+*(.data)}
-    ${RELOCATING+*(.gnu.linkonce.d.*)}
-    ${CONSTRUCTING+CONSTRUCTORS}; /* Is this needed? */
-  }
-  ${RELOCATING+ _edata = . ;}
-  
-   /* Added to handle pic code */
-  .got : {  
-    ${RELOCATING+*(.got)}
-  }
-
-  .got1 : {  
-    ${RELOCATING+*(.got1)}
-  }
-
-  .got2 : {  
-    ${RELOCATING+*(.got2)}
-  }
-
-  /* Added by Sathya to handle C++ exceptions */
-  .eh_frame : {  
-    ${RELOCATING+*(.eh_frame)}
-  }
-  
-  .jcr : {  
-    ${RELOCATING+*(.jcr)}
-  }
-
-  .gcc_except_table : {  
-    ${RELOCATING+*(.gcc_except_table)}
-  }
-
-  /* Alignments by 8 to ensure that _SDA_BASE_ on a word boundary */
-  /* Note that .sdata and .sbss must be contiguous */
-  ${RELOCATING+. = ALIGN(8);}
-  ${RELOCATING+ _ssro = .;}
-  .sdata : {
-    ${RELOCATING+*(.sdata)}
-    ${RELOCATING+*(.sdata.*)}
-    ${RELOCATING+*(.gnu.linkonce.s.*)}
-  }
-  ${RELOCATING+. = ALIGN(4);}
-  .sbss : {
-    ${RELOCATING+PROVIDE (__sbss_start = .);}	
-    ${RELOCATING+*(.sbss)}
-    ${RELOCATING+*(.sbss.*)}
-    ${RELOCATING+*(.gnu.linkonce.sb.*)}
-    ${RELOCATING+PROVIDE (__sbss_end = .);}
-  }
-  ${RELOCATING+. = ALIGN(8);}
-  ${RELOCATING+ _essro = .;}
-  ${RELOCATING+ _ssro_size = _essro - _ssro;}
-  ${RELOCATING+PROVIDE (_SDA_BASE_ = _ssro + (_ssro_size / 2 ));}
-
-  ${RELOCATING+ . = ALIGN(4);}
-  ${RELOCATING+ _fbss = .;}
-  .bss : {
-    ${RELOCATING+PROVIDE (__bss_start = .);}	
-    ${RELOCATING+*(.bss)}
-    ${RELOCATING+*(.bss.*)}
-    ${RELOCATING+*(.gnu.linkonce.b.*)}
-    ${RELOCATING+*(COMMON)}
-    ${RELOCATING+. = ALIGN(. != 0 ? 4 : 1);}
-    
-    ${RELOCATING+PROVIDE (__bss_end = .);}
-
-  }
-
-  ${RELOCATING+ . = ALIGN(4);}
-
-  .heap : {
-    ${RELOCATING+ _heap = .;}
-    ${RELOCATING+ _heap_start = .;}
-    ${RELOCATING+ . += _HEAP_SIZE;}
-    ${RELOCATING+ _heap_end = .;}
-  } 
-
-  ${RELOCATING+ . = ALIGN(4);}
-
-  .stack : {
-    ${RELOCATING+ _stack_end = .;}
-    ${RELOCATING+ . += _STACK_SIZE;}
-    ${RELOCATING+ . = ALIGN(. != 0 ? 8 : 1);}
-    ${RELOCATING+ _stack = .;}
-    ${RELOCATING+ _end = .;}
-  }
-
-  .tdata : {  
-    ${RELOCATING+*(.tdata)}
-    ${RELOCATING+*(.tdata.*)}
-    ${RELOCATING+*(.gnu.linkonce.td.*)}
-  }
-  .tbss : {  
-    ${RELOCATING+*(.tbss)}
-    ${RELOCATING+*(.tbss.*)}
-    ${RELOCATING+*(.gnu.linkonce.tb.*)}
-  }
-}
-EOF
diff --git a/ld/scripttempl/stm8.sc b/ld/scripttempl/stm8.sc
new file mode 100644
index 0000000000..642b906d4f
--- /dev/null
+++ b/ld/scripttempl/stm8.sc
@@ -0,0 +1,270 @@
+# Copyright (C) 2014-2018 Free Software Foundation, Inc.
+# 
+# Copying and distribution of this file, with or without modification,
+# are permitted in any medium without royalty provided the copyright
+# notice and this notice are preserved.
+
+test -z "$ENTRY" && ENTRY=_start
+
+cat <<EOF
+/* Copyright (C) 2014-2016 Free Software Foundation, Inc.
+
+   Copying and distribution of this script, with or without modification,
+   are permitted in any medium without royalty provided the copyright
+   notice and this notice are preserved.  */
+   
+${RELOCATING+ENTRY (${ENTRY})}
+
+OUTPUT_FORMAT("${OUTPUT_FORMAT}","${OUTPUT_FORMAT}","${OUTPUT_FORMAT}")
+OUTPUT_ARCH(${ARCH})
+
+__TEXT_REGION_LENGTH__ = DEFINED(__TEXT_REGION_LENGTH__) ? __TEXT_REGION_LENGTH__ : $TEXT_LENGTH;
+__DATA_REGION_LENGTH__ = DEFINED(__DATA_REGION_LENGTH__) ? __DATA_REGION_LENGTH__ : $DATA_LENGTH;
+__EEPROM_REGION_LENGTH__ = DEFINED(__EEPROM_REGION_LENGTH__) ? __EEPROM_REGION_LENGTH__ : 64K;
+__FUSE_REGION_LENGTH__ = DEFINED(__FUSE_REGION_LENGTH__) ? __FUSE_REGION_LENGTH__ : 1K;
+__LOCK_REGION_LENGTH__ = DEFINED(__LOCK_REGION_LENGTH__) ? __LOCK_REGION_LENGTH__ : 1K;
+__SIGNATURE_REGION_LENGTH__ = DEFINED(__SIGNATURE_REGION_LENGTH__) ? __SIGNATURE_REGION_LENGTH__ : 1K;
+__USER_SIGNATURE_REGION_LENGTH__ = DEFINED(__USER_SIGNATURE_REGION_LENGTH__) ? __USER_SIGNATURE_REGION_LENGTH__ : 1K;
+
+MEMORY
+{
+  data   (rw!x) : ORIGIN = 0x0, LENGTH = __DATA_REGION_LENGTH__
+  eeprom (rw!x) : ORIGIN = 0x4000, LENGTH = __EEPROM_REGION_LENGTH__
+  fuse      (rw!x) : ORIGIN = 0x5000, LENGTH = __FUSE_REGION_LENGTH__
+  lock      (rw!x) : ORIGIN = 0x5100, LENGTH = __LOCK_REGION_LENGTH__
+  text   (rx)   : ORIGIN = 0x8000, LENGTH = __TEXT_REGION_LENGTH__
+  signature (rw!x) : ORIGIN = 0x840000, LENGTH = __SIGNATURE_REGION_LENGTH__
+  user_signatures (rw!x) : ORIGIN = 0x850000, LENGTH = __USER_SIGNATURE_REGION_LENGTH__
+}
+
+SECTIONS
+{
+  /* Read-only sections, merged into text segment: */
+  ${TEXT_DYNAMIC+${DYNAMIC}}
+  .hash        ${RELOCATING-0} : { *(.hash)		}
+  .dynsym      ${RELOCATING-0} : { *(.dynsym)		}
+  .dynstr      ${RELOCATING-0} : { *(.dynstr)		}
+  .gnu.version ${RELOCATING-0} : { *(.gnu.version)	}
+  .gnu.version_d ${RELOCATING-0} : { *(.gnu.version_d)	}
+  .gnu.version_r ${RELOCATING-0} : { *(.gnu.version_r)	}
+
+  .rel.init    ${RELOCATING-0} : { *(.rel.init)		}
+  .rela.init   ${RELOCATING-0} : { *(.rela.init)	}
+  .rel.text    ${RELOCATING-0} :
+    {
+      *(.rel.text)
+      ${RELOCATING+*(.rel.text.*)}
+      ${RELOCATING+*(.rel.gnu.linkonce.t*)}
+    }
+  .rela.text   ${RELOCATING-0} :
+    {
+      *(.rela.text)
+      ${RELOCATING+*(.rela.text.*)}
+      ${RELOCATING+*(.rela.gnu.linkonce.t*)}
+    }
+  .rel.fini    ${RELOCATING-0} : { *(.rel.fini)		}
+  .rela.fini   ${RELOCATING-0} : { *(.rela.fini)	}
+  .rel.rodata  ${RELOCATING-0} :
+    {
+      *(.rel.rodata)
+      ${RELOCATING+*(.rel.rodata.*)}
+      ${RELOCATING+*(.rel.gnu.linkonce.r*)}
+    }
+  .rela.rodata ${RELOCATING-0} :
+    {
+      *(.rela.rodata)
+      ${RELOCATING+*(.rela.rodata.*)}
+      ${RELOCATING+*(.rela.gnu.linkonce.r*)}
+    }
+  .rel.data    ${RELOCATING-0} :
+    {
+      *(.rel.data)
+      ${RELOCATING+*(.rel.data.*)}
+      ${RELOCATING+*(.rel.gnu.linkonce.d*)}
+    }
+  .rela.data   ${RELOCATING-0} :
+    {
+      *(.rela.data)
+      ${RELOCATING+*(.rela.data.*)}
+      ${RELOCATING+*(.rela.gnu.linkonce.d*)}
+    }
+  .rel.ctors   ${RELOCATING-0} : { *(.rel.ctors)	}
+  .rela.ctors  ${RELOCATING-0} : { *(.rela.ctors)	}
+  .rel.dtors   ${RELOCATING-0} : { *(.rel.dtors)	}
+  .rela.dtors  ${RELOCATING-0} : { *(.rela.dtors)	}
+  .rel.got     ${RELOCATING-0} : { *(.rel.got)		}
+  .rela.got    ${RELOCATING-0} : { *(.rela.got)		}
+  .rel.bss     ${RELOCATING-0} : { *(.rel.bss)		}
+  .rela.bss    ${RELOCATING-0} : { *(.rela.bss)		}
+  .rel.plt     ${RELOCATING-0} : { *(.rel.plt)		}
+  .rela.plt    ${RELOCATING-0} : { *(.rela.plt)		}
+
+  /* Internal text space or external memory.  */
+  .text ${RELOCATING-0} :
+  {
+    *(.vectors)
+    KEEP(*(.vectors))
+
+    /* For data that needs to reside in the lower 64k of progmem.  */
+    ${RELOCATING+ *(.progmem.gcc*)}
+
+    /* PR 13812: Placing the trampolines here gives a better chance
+       that they will be in range of the code that uses them.  */
+    ${RELOCATING+. = ALIGN(2);}
+    ${CONSTRUCTING+ __trampolines_start = . ; }
+    /* The jump trampolines for the 16-bit limited relocs will reside here.  */
+    *(.trampolines)
+    ${RELOCATING+ *(.trampolines*)}
+    ${CONSTRUCTING+ __trampolines_end = . ; }
+
+    /* avr-libc expects these data to reside in lower 64K. */
+    ${RELOCATING+ *libprintf_flt.a:*(.progmem.data)}
+    ${RELOCATING+ *libc.a:*(.progmem.data)}
+
+    ${RELOCATING+ *(.progmem*)}
+    
+    ${RELOCATING+. = ALIGN(2);}
+
+    /* For future tablejump instruction arrays for 3 byte pc devices.
+       We don't relax jump/call instructions within these sections.  */
+    *(.jumptables) 
+    ${RELOCATING+ *(.jumptables*)}
+
+    /* For code that needs to reside in the lower 128k progmem.  */
+    *(.lowtext)
+    ${RELOCATING+ *(.lowtext*)}
+
+    ${CONSTRUCTING+ __ctors_start = . ; }
+    ${CONSTRUCTING+ *(.ctors) }
+    ${CONSTRUCTING+ __ctors_end = . ; }
+    ${CONSTRUCTING+ __dtors_start = . ; }
+    ${CONSTRUCTING+ *(.dtors) }
+    ${CONSTRUCTING+ __dtors_end = . ; }
+    KEEP(SORT(*)(.ctors))
+    KEEP(SORT(*)(.dtors))
+
+    /* From this point on, we don't bother about wether the insns are
+       below or above the 16 bits boundary.  */
+    *(.init0)  /* Start here after reset.  */
+    KEEP (*(.init0))
+    *(.init1)
+    KEEP (*(.init1))
+    *(.init2)  /* Clear __zero_reg__, set up stack pointer.  */
+    KEEP (*(.init2))
+    *(.init3)
+    KEEP (*(.init3))
+    *(.init4)  /* Initialize data and BSS.  */
+    KEEP (*(.init4))
+    *(.init5)
+    KEEP (*(.init5))
+    *(.init6)  /* C++ constructors.  */
+    KEEP (*(.init6))
+    *(.init7)
+    KEEP (*(.init7))
+    *(.init8)
+    KEEP (*(.init8))
+    *(.init9)  /* Call main().  */
+    KEEP (*(.init9))
+    *(.text)
+    ${RELOCATING+. = ALIGN(2);}
+    ${RELOCATING+ *(.text.*)}
+    ${RELOCATING+. = ALIGN(2);}
+    *(.fini9)  /* _exit() starts here.  */
+    KEEP (*(.fini9))
+    *(.fini8)
+    KEEP (*(.fini8))
+    *(.fini7)
+    KEEP (*(.fini7))
+    *(.fini6)  /* C++ destructors.  */
+    KEEP (*(.fini6))
+    *(.fini5)
+    KEEP (*(.fini5))
+    *(.fini4)
+    KEEP (*(.fini4))
+    *(.fini3)
+    KEEP (*(.fini3))
+    *(.fini2)
+    KEEP (*(.fini2))
+    *(.fini1)
+    KEEP (*(.fini1))
+    *(.fini0)  /* Infinite loop after program termination.  */
+    KEEP (*(.fini0))
+    ${RELOCATING+ _etext = . ; }
+  } ${RELOCATING+ > text}
+
+  .data        ${RELOCATING-0} :
+  {
+    ${RELOCATING+ PROVIDE (__data_start = .) ; }
+    *(.data)
+    ${RELOCATING+ *(.data*)}
+    *(.rodata)  /* We need to include .rodata here if gcc is used */
+    ${RELOCATING+ *(.rodata*)} /* with -fdata-sections.  */
+    *(.gnu.linkonce.d*)
+    ${RELOCATING+. = ALIGN(2);}
+    ${RELOCATING+ _edata = . ; }
+    ${RELOCATING+ PROVIDE (__data_end = .) ; }
+  } ${RELOCATING+ > data ${RELOCATING+AT> text}}
+
+  .bss ${RELOCATING+ ADDR(.data) + SIZEOF (.data)} ${RELOCATING-0} :${RELOCATING+ AT (ADDR (.bss))}
+  {
+    ${RELOCATING+ PROVIDE (__bss_start = .) ; }
+    *(.bss)
+    ${RELOCATING+ *(.bss*)}
+    *(COMMON)
+    ${RELOCATING+ PROVIDE (__bss_end = .) ; }
+  } ${RELOCATING+ > data}
+
+  ${RELOCATING+ __data_load_start = LOADADDR(.data); }
+  ${RELOCATING+ __data_load_end = __data_load_start + SIZEOF(.data); }
+
+  /* Global data not cleared after reset.  */
+  .noinit ${RELOCATING+ ADDR(.bss) + SIZEOF (.bss)} ${RELOCATING-0}: ${RELOCATING+ AT (ADDR (.noinit))}
+  {
+    ${RELOCATING+ PROVIDE (__noinit_start = .) ; }
+    *(.noinit*)
+    ${RELOCATING+ PROVIDE (__noinit_end = .) ; }
+    ${RELOCATING+ _end = . ;  }
+    ${RELOCATING+ PROVIDE (__heap_start = .) ; }
+  } ${RELOCATING+ > data}
+
+  .eeprom ${RELOCATING-0}:
+  {
+    /* See .data above...  */
+    KEEP(*(.eeprom*))
+    ${RELOCATING+ __eeprom_end = . ; }
+  } ${RELOCATING+ > eeprom}
+
+  .fuse ${RELOCATING-0}:
+  {
+    KEEP(*(.fuse))
+    KEEP(*(.lfuse))
+    KEEP(*(.hfuse))
+    KEEP(*(.efuse))
+  } ${RELOCATING+ > fuse}
+
+  .lock ${RELOCATING-0}:
+  {
+    KEEP(*(.lock*))
+  } ${RELOCATING+ > lock}
+
+  .signature ${RELOCATING-0}:
+  {
+    KEEP(*(.signature*))
+  } ${RELOCATING+ > signature}
+
+  /* Stabs debugging sections.  */
+  .stab 0 : { *(.stab) }
+  .stabstr 0 : { *(.stabstr) }
+  .stab.excl 0 : { *(.stab.excl) }
+  .stab.exclstr 0 : { *(.stab.exclstr) }
+  .stab.index 0 : { *(.stab.index) }
+  .stab.indexstr 0 : { *(.stab.indexstr) }
+  .comment 0 : { *(.comment) } 
+  .note.gnu.build-id : { *(.note.gnu.build-id) }
+EOF
+
+. $srcdir/scripttempl/DWARF.sc
+
+cat <<EOF
+}
+EOF
diff --git a/opcodes/stm8-dis.c b/opcodes/stm8-dis.c
index 751c62c2b7..2eee63060b 100644
--- a/opcodes/stm8-dis.c
+++ b/opcodes/stm8-dis.c
@@ -1,5 +1,5 @@
 /* Disassemble STM8 instructions.
-   Copyright (C) 1999-2016 Free Software Foundation, Inc.
+   Copyright (C) 1999-2018 Free Software Foundation, Inc.
 
    Contributed by Ake Rehnman
 
@@ -344,32 +344,65 @@ int stm8_dis(bfd_vma addr, unsigned int op)
 	unsigned char *bufp;
 	char s[256];
 	int i=0;
-	int j;
 	char c;
 	int operandlen;
+	int operand, dir;
 
 	while (stm8_opcodes[i].name)
 	{
 		if (op == stm8_opcodes[i].bin_opcode)
 		{
-			bufp=buf;
-			s[0] = 0;
 			dinfo->fprintf_func(dinfo->stream, "%s",stm8_opcodes[i].name);
 			operandlen = stm8_compute_insn_size(stm8_opcodes[i])-stm8_opcode_size(op);
 			instrlen += operandlen;
 			if (fetch_data(buf,addr,dinfo,operandlen))
 				return 0;
+
 			lastlabeladdr = 0;
-			for (j=0;j<5;j++)
+			c = ' ';
+
+			for (int curr_operand = 0; curr_operand < stm8_num_opcode_operands(stm8_opcodes[i]); curr_operand++)
 			{
-				s[0]=0;
-				bufp+=stm8_operands(s, bufp, stm8_opcodes[i].constraints[j]);
-				if (s[0])
+				bufp = buf;
+				dir = 1;
+				operand = 0;
+
+				/* mov insn operands are reversed */
+				if ((op == 0x35) || (op == 0x45) || (op == 0x55))
 				{
-					if (j==0) c=' '; else c=',';
-					dinfo->fprintf_func(dinfo->stream, "%c%s",c,s);
+					dir = -1;
+					operand = stm8_num_opcode_operands(stm8_opcodes[i]) - 1;
+				}
+
+				for (int j = 0; j < stm8_num_opcode_operands(stm8_opcodes[i]); j++, operand += dir)
+				{
+					s[0] = 0;
+					bufp += stm8_operands(s, bufp, stm8_opcodes[i].constraints[operand]);
+					if (operand == curr_operand)
+					{
+						if (s[0])
+						{
+							dinfo->fprintf_func(dinfo->stream, "%c%s",c,s);
+							c = ',';
+						}
+						break;
+					}
 				}
 			}
+			
+			
+//			c = ' ';
+//			for (j=0; j<5; j++, operand += dir)
+//			{
+//				s[0]=0;
+//				bufp += stm8_operands(s, bufp, stm8_opcodes[i].constraints[operand]);
+//				if (s[0])
+//				{
+//					dinfo->fprintf_func(dinfo->stream, "%c%s",c,s);
+//					c = ',';
+//				}
+//			}
+
 			if (lastlabeladdr)
 			{
 				dinfo->fprintf_func(dinfo->stream, " ;");
diff --git a/opcodes/stm8-opc.c b/opcodes/stm8-opc.c
index 3a600d66d3..9516d859f2 100644
--- a/opcodes/stm8-opc.c
+++ b/opcodes/stm8-opc.c
@@ -1,5 +1,5 @@
 /* stm8-opc.c -- Table of opcodes for the STM8 processor.
-   Copyright (C) 2007-2016 Free Software Foundation, Inc.
+   Copyright (C) 2007-2018 Free Software Foundation, Inc.
    Contributed by Ake Rehnman ake dot rehnman (at) gmail dot com
 
    This file is part of the GNU opcodes library.
@@ -729,6 +729,13 @@ const struct stm8_opcodes_s stm8_opcodes[] =
   {NULL, {ST8_END}, 0},
 };
 
+int stm8_num_opcode_operands(struct stm8_opcodes_s opcode)
+{
+	int i;
+	for(i = 0; opcode.constraints[i]; i++);
+	return i;
+}
+
 unsigned int stm8_opcode_size(unsigned int number)
 {
 	int i;
-- 
2.12.2