From 69776a7af5b7a3697c5d32f3265d2a8de8cb5b32 Mon Sep 17 00:00:00 2001 From: Xavier ASUS Date: Tue, 29 Oct 2019 00:43:05 +0100 Subject: [PATCH 7/10] Added --gc-sections and hi8/lo8/hh8 --- bfd/elf32-stm8.c | 229 ++++++++++++++++++++++++---- bfd/libbfd.h | 3 + bfd/reloc.c | 15 ++ gas/config/tc-stm8.c | 163 +++++++++++++++++--- gas/config/tc-stm8.h | 2 +- include/elf/stm8.h | 3 + include/opcode/stm8.h | 5 +- opcodes/stm8-dis.c | 31 +++- opcodes/stm8-opc.c | 6 + 9 files changed, 400 insertions(+), 57 deletions(-) diff --git a/bfd/elf32-stm8.c b/bfd/elf32-stm8.c index 37995553..5eb3c814 100644 --- a/bfd/elf32-stm8.c +++ b/bfd/elf32-stm8.c @@ -26,17 +26,16 @@ #include "elf-bfd.h" #include "elf/stm8.h" -//#include "elf32-avr.h" #include "bfd_stdint.h" bfd_reloc_status_type bfd_elf_stm8_spec_reloc (bfd *abfd ATTRIBUTE_UNUSED, - arelent *reloc_entry, - asymbol *symbol, - void *data ATTRIBUTE_UNUSED, - asection *input_section, - bfd *output_bfd, - char **error_message ATTRIBUTE_UNUSED); + arelent *reloc_entry, + asymbol *symbol, + void *data ATTRIBUTE_UNUSED, + asection *input_section, + bfd *output_bfd, + char **error_message ATTRIBUTE_UNUSED); static reloc_howto_type elf32_stm8_howto_table_1[] = { @@ -96,7 +95,8 @@ static reloc_howto_type elf32_stm8_howto_table_1[] = bfd_elf_generic_reloc, /* special_function */ "R_STM8_24", /* name */ FALSE, /* partial_inplace */ - 0xff000000, /* src_mask */ + //0xff000000, /* src_mask */ + 0x0, /* src_mask */ 0x00ffffff, /* dst_mask */ FALSE), /* pcrel_offset */ @@ -142,30 +142,75 @@ static reloc_howto_type elf32_stm8_howto_table_1[] = 0x0, /* src_mask */ 0xff, /* dst_mask */ TRUE), /* pcrel_offset */ + + /* lo 8 bit relocation. */ + HOWTO (R_STM8_LO8, /* type */ + 0, /* rightshift */ + 0, /* size (0 = byte, 1 = short, 2 = long) */ + 8, /* bitsize */ + FALSE, /* pc_relative */ + 0, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_STM8_LO8", /* name */ + FALSE, /* partial_inplace */ + 0x0, /* src_mask */ + 0xff, /* dst_mask */ + FALSE), /* pcrel_offset */ + + /* hi 8 bit relocation. */ + HOWTO (R_STM8_HI8, /* type */ + 8, /* rightshift */ + 0, /* size (0 = byte, 1 = short, 2 = long) */ + 8, /* bitsize */ + FALSE, /* pc_relative */ + 0, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_STM8_HI8", /* name */ + FALSE, /* partial_inplace */ + 0x0, /* src_mask */ + 0xff, /* dst_mask */ + FALSE), /* pcrel_offset */ + + /* hh 8 bit relocation. */ + HOWTO (R_STM8_HH8, /* type */ + 16, /* rightshift */ + 0, /* size (0 = byte, 1 = short, 2 = long) */ + 8, /* bitsize */ + FALSE, /* pc_relative */ + 0, /* bitpos */ + complain_overflow_dont, /* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_STM8_HH8", /* name */ + FALSE, /* partial_inplace */ + 0x0, /* src_mask */ + 0xff, /* dst_mask */ + FALSE), /* pcrel_offset */ }; //stupid bfd_elf_generic_reloc cant handle 24-bit relocations //so we have to write our own... bfd_reloc_status_type bfd_elf_stm8_spec_reloc (bfd *abfd ATTRIBUTE_UNUSED, - arelent *reloc_entry, - asymbol *symbol, - void *data ATTRIBUTE_UNUSED, - asection *input_section ATTRIBUTE_UNUSED, - bfd *output_bfd, - char **error_message ATTRIBUTE_UNUSED) + arelent *reloc_entry, + asymbol *symbol, + void *data ATTRIBUTE_UNUSED, + asection *input_section ATTRIBUTE_UNUSED, + bfd *output_bfd, + char **error_message ATTRIBUTE_UNUSED) { if (output_bfd != NULL && (symbol->flags & BSF_SECTION_SYM) == 0 && (! reloc_entry->howto->partial_inplace - || reloc_entry->addend == 0)) + || reloc_entry->addend == 0)) { reloc_entry->address += input_section->output_offset+1; return bfd_reloc_ok; } if (output_bfd == NULL) - return bfd_reloc_continue; + return bfd_reloc_continue; reloc_entry->address += input_section->output_offset-1; return bfd_reloc_continue; } @@ -203,7 +248,10 @@ static const struct elf32_stm8_reloc_map elf32_stm8_reloc_map[] = { BFD_RELOC_16, R_STM8_16 }, { BFD_RELOC_24, R_STM8_24 }, { BFD_RELOC_32, R_STM8_32 }, - { BFD_RELOC_8_PCREL, R_STM8_8_PCREL} + { BFD_RELOC_8_PCREL, R_STM8_8_PCREL}, + { BFD_RELOC_STM8_LO8, R_STM8_LO8}, + { BFD_RELOC_STM8_HI8, R_STM8_HI8}, + { BFD_RELOC_STM8_HH8, R_STM8_HH8}, }; static reloc_howto_type * @@ -235,12 +283,12 @@ elf32_stm8_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, static void elf32_stm8_post_process_headers (bfd *abfd, - struct bfd_link_info *info ATTRIBUTE_UNUSED) + struct bfd_link_info *info ATTRIBUTE_UNUSED) { Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd); // i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_STANDALONE; // i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_ARM; -// i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi; +// i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi; i_ehdrp->e_ident[EI_ABIVERSION] = 0; } @@ -253,33 +301,158 @@ elf32_stm8_modify_segment_map (bfd *abfd, m = elf_seg_map (abfd); while (m) { - m->includes_filehdr = 0; - m->includes_phdrs = 0; - m = m->next; + m->includes_filehdr = 0; + m->includes_phdrs = 0; + m = m->next; } return TRUE; } +static bfd_boolean +elf32_stm8_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED, + struct bfd_link_info *info, + bfd *input_bfd, + asection *input_section, + bfd_byte *contents, + Elf_Internal_Rela *relocs, + Elf_Internal_Sym *local_syms, + asection **local_sections) +{ + Elf_Internal_Shdr *symtab_hdr; + struct elf_link_hash_entry **sym_hashes; + Elf_Internal_Rela *rel; + Elf_Internal_Rela *relend; + + symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr; + sym_hashes = elf_sym_hashes (input_bfd); + relend = relocs + input_section->reloc_count; + + for (rel = relocs; rel < relend; rel ++) + { + reloc_howto_type *howto; + unsigned long r_symndx; + Elf_Internal_Sym *sym; + asection *sec; + struct elf_link_hash_entry *h; + bfd_vma relocation; + bfd_reloc_status_type r; + const char *name; + int r_type; + + r_type = ELF32_R_TYPE (rel->r_info); + r_symndx = ELF32_R_SYM (rel->r_info); + howto = elf32_stm8_howto_from_type(r_type); + h = NULL; + sym = NULL; + sec = NULL; + + if (r_symndx < symtab_hdr->sh_info) + { + sym = local_syms + r_symndx; + sec = local_sections [r_symndx]; + relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); + + name = bfd_elf_string_from_elf_section + (input_bfd, symtab_hdr->sh_link, sym->st_name); + if (name == NULL || name[0] == 0) + name = bfd_section_name (input_bfd, sec); + } + else + { + bfd_boolean unresolved_reloc, warned, ignored; + + RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, + r_symndx, symtab_hdr, sym_hashes, + h, sec, relocation, + unresolved_reloc, warned, ignored); + + name = h->root.root.string; + } -#define elf_backend_post_process_headers elf32_stm8_post_process_headers + if (sec != NULL && discarded_section (sec)) + RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, + rel, 1, relend, howto, 0, contents); + + if (bfd_link_relocatable (info)) + continue; + + if (!howto) + { + (*info->callbacks->einfo)("%s unkown reloc type %lu\n", __FILE__, r_type); + return FALSE; + } + +#if 0 + fprintf(stderr,"reloc %s offset=%4.4lx addend=%4.4lx name=%s\n", howto->name, rel->r_offset, rel->r_addend, name); +#endif + + r = _bfd_final_link_relocate (howto, input_bfd, input_section, + contents, rel->r_offset, + relocation, rel->r_addend); + + if (r != bfd_reloc_ok) + { + const char * msg = (const char *) NULL; + + switch (r) + { + case bfd_reloc_overflow: + (*info->callbacks->reloc_overflow) + (info, (h ? &h->root : NULL), name, howto->name, + (bfd_vma) 0, input_bfd, input_section, rel->r_offset); + break; + + case bfd_reloc_undefined: + (*info->callbacks->undefined_symbol) + (info, name, input_bfd, input_section, rel->r_offset, TRUE); + break; + + case bfd_reloc_outofrange: + msg = _("internal error: out of range error"); + break; + + case bfd_reloc_notsupported: + msg = _("internal error: unsupported relocation error"); + break; + + case bfd_reloc_dangerous: + msg = _("internal error: dangerous relocation"); + break; + + default: + msg = _("internal error: unknown error"); + break; + } + + if (msg) + (*info->callbacks->warning) (info, msg, name, input_bfd, + input_section, rel->r_offset); + } + + } + return TRUE; +} + +#define elf_backend_post_process_headers elf32_stm8_post_process_headers #define elf_backend_modify_segment_map elf32_stm8_modify_segment_map #define bfd_elf32_bfd_reloc_type_lookup elf32_stm8_reloc_type_lookup #define bfd_elf32_bfd_reloc_name_lookup elf32_stm8_reloc_name_lookup #define ELF_ARCH bfd_arch_stm8 -//#define ELF_TARGET_ID AVR_ELF_DATA #define ELF_TARGET_ID GENERIC_ELF_DATA #define ELF_MACHINE_CODE EM_STM8 -//#define ELF_OSABI ELFOSABI_STANDALONE -//#define ELF_MACHINE_ALT1 EM_STM8_OLD #define ELF_MAXPAGESIZE 1 -//#define TARGET_LITTLE_SYM stm8_elf32_vec -//#define TARGET_LITTLE_NAME "elf32-stm8" #define TARGET_BIG_SYM stm8_elf32_vec #define TARGET_BIG_NAME "elf32-stm8" #define elf_info_to_howto elf32_stm8_info_to_howto #define elf_info_to_howto_rel NULL +#define elf_backend_can_gc_sections 1 +#define elf_backend_relocate_section elf32_stm8_relocate_section +#define bfd_elf32_bfd_link_hash_table_create _bfd_elf_link_hash_table_create +#define bfd_elf32_bfd_final_link bfd_elf_gc_common_final_link + #include "elf32-target.h" + diff --git a/bfd/libbfd.h b/bfd/libbfd.h index fca8c19e..edb2df8a 100644 --- a/bfd/libbfd.h +++ b/bfd/libbfd.h @@ -3189,6 +3189,9 @@ static const char *const bfd_reloc_code_real_names[] = { "@@uninitialized@@", "BFD_RELOC_WASM32_INDEX", "BFD_RELOC_WASM32_PLT_SIG", "BFD_RELOC_STM8_BIT_FLD", + "BFD_RELOC_STM8_LO8", + "BFD_RELOC_STM8_HI8", + "BFD_RELOC_STM8_HH8", "@@overflow: BFD_RELOC_UNUSED@@", }; #endif diff --git a/bfd/reloc.c b/bfd/reloc.c index c7b862aa..4ad743a2 100644 --- a/bfd/reloc.c +++ b/bfd/reloc.c @@ -7936,6 +7936,21 @@ ENUM ENUMDOC STM8 bit field immediate for BTJx, BCPL, BSET, BRES instruction. +ENUM + BFD_RELOC_STM8_LO8 +ENUMDOC + STM8 extract LSB from word. + +ENUM + BFD_RELOC_STM8_HI8 +ENUMDOC + STM8 extract MSB from word. + +ENUM + BFD_RELOC_STM8_HH8 +ENUMDOC + STM8 extract MMSB from 24-bit address. + ENDSENUM BFD_RELOC_UNUSED CODE_FRAGMENT diff --git a/gas/config/tc-stm8.c b/gas/config/tc-stm8.c index 38fa5072..e670cb1d 100644 --- a/gas/config/tc-stm8.c +++ b/gas/config/tc-stm8.c @@ -26,6 +26,7 @@ #include #include #include "opcode/stm8.h" +#include typedef enum { OP_ILLEGAL = 0, @@ -43,9 +44,31 @@ typedef enum { OP_PTRW_Y, OP_PTRE_X, OP_PTRE_Y, - OP_REGISTER + OP_REGISTER, + OP_HI8, + OP_LO8, + OP_HH8 } stm8_operand_t; +typedef struct +{ + /* Name of the expression modifier allowed with .byte, .word, etc. */ + const char *name; + + /* Only allowed with n bytes of data. */ + int nbytes; + + /* Associated RELOC. */ + bfd_reloc_code_real_type reloc; + + /* Part of the error message. */ + const char *error; + + /* Internal operand. */ + stm8_operand_t op; + +} exp_mod_data_t; + static struct hash_control *stm8_hash; const char comment_chars[] = ";"; @@ -133,7 +156,7 @@ md_begin (void) { const struct stm8_opcodes_s *opcode; stm8_hash = hash_new (); - + /* Insert unique names into hash table. This hash table then provides a quick index to the first opcode with a particular name in the opcode table. */ @@ -198,6 +221,15 @@ md_begin (void) } +const exp_mod_data_t exp_mod_data[] = +{ + /* Default, must be first. */ + { "", 0, BFD_RELOC_16, "", OP_ILLEGAL }, + { "lo8", 1, BFD_RELOC_STM8_LO8, "`lo8' ", OP_LO8 }, + { "hi8", 1, BFD_RELOC_STM8_HI8, "`hi8' ", OP_HI8 }, + { "hh8", 1, BFD_RELOC_STM8_HH8, "`hi8' ", OP_HH8 }, +}; + static inline char * skip_space (char *s) { @@ -239,8 +271,6 @@ md_operand (expressionS * exp __attribute__((unused))) void print_fixup (fixS *); - - /* Attempt to simplify or eliminate a fixup. To indicate that a fixup has been eliminated, set fix->fx_done. If fix->fx_addsy is non-NULL, we will have to generate a reloc entry. */ @@ -335,6 +365,18 @@ md_apply_fix (fixS *fixP, valueT *valP, segT segment ATTRIBUTE_UNUSED) fixP->fx_done = 1; break; + case BFD_RELOC_STM8_LO8: + *buf = 0xff & val; + break; + + case BFD_RELOC_STM8_HI8: + *buf = (0xff00 & val) >> 8; + break; + + case BFD_RELOC_STM8_HH8: + *buf = (0xff0000 & val) >> 16; + break; + default: printf(_("md_apply_fix: unknown r_type 0x%x\n"), fixP->fx_r_type); abort (); @@ -526,13 +568,13 @@ int read_arg_ptr(char *str, expressionS *exps) char *s; char *p; char c; - + if ((str[0]=='[') && (strstr(str,"]"))) { s = str; s++; input_line_pointer=s; - + /* first eat up .w and .e */ if ((p = strstr(s,".w]"))) { @@ -545,11 +587,11 @@ int read_arg_ptr(char *str, expressionS *exps) c = *p; *p = 0; } - + expression(exps); if (stm8_debug) print_expr(exps); - + /* restore c */ if (p) *p = c; @@ -615,7 +657,7 @@ int read_arg(char *str, expressionS *exps) print_expr(exps); return 1; } - + char strx[256]; strncpy(strx,str,sizeof(strx)); toupperstr(strx); @@ -719,6 +761,50 @@ int read_arg(char *str, expressionS *exps) exps->X_md=OP_OFF_SP; return 1; } + else + { + /* The first entry of exp_mod_data[] contains an entry if no + expression modifier is present. Skip it. */ + size_t i; + + for (i = 1; i < ARRAY_SIZE (exp_mod_data); i++) + { + const exp_mod_data_t *const pexp = &exp_mod_data[i]; + const size_t len = strlen (pexp->name); + const int result = strncasecmp (str, pexp->name, len); + + if (!result) + { + str += len; + while (isspace(*str)) + str++; + + if (*str == '(') + { + input_line_pointer = ++str; + + expression(exps); + + if (*input_line_pointer == ')') + { + input_line_pointer++; + + exps->X_md = pexp->op; + return 1; + } + else + { + as_bad (_("`)' required")); + return 0; + } + } + + input_line_pointer = str; + + break; + } + } + } char *p; char c; @@ -777,7 +863,7 @@ void stm8_bfd_out(struct stm8_opcodes_s op, expressionS exp[], int count, char * int i; int arg = 0; int dir = 1; - + /* if count is negative the arguments are reversed */ if (count < 0) { @@ -833,6 +919,21 @@ void stm8_bfd_out(struct stm8_opcodes_s op, expressionS exp[], int count, char * case ST8_BIT_0: fix_new_exp(frag_now, where-3, 1, &exp[arg], FALSE, BFD_RELOC_STM8_BIT_FLD); break; + case ST8_HI8: + fix_new_exp(frag_now, where, 1, &exp[arg], FALSE, BFD_RELOC_STM8_HI8); + bfd_put_bits(0xaaaaaaaa, frag, 8, true); + frag+=1; + break; + case ST8_LO8: + fix_new_exp(frag_now, where, 1, &exp[arg], FALSE, BFD_RELOC_STM8_LO8); + bfd_put_bits(0xaaaaaaaa, frag, 8, true); + frag+=1; + break; + case ST8_HH8: + fix_new_exp(frag_now, where, 1, &exp[arg], FALSE, BFD_RELOC_STM8_HH8); + bfd_put_bits(0xaaaaaaaa, frag, 8, true); + frag+=1; + break; default: break; } @@ -945,6 +1046,18 @@ int cmpspec(stm8_addr_mode_t addr_mode[], expressionS exps[], int count) if (addr_mode[i] == ST8_SHORTMEM) continue; break; + case OP_LO8: + if (addr_mode[i] == ST8_LO8) + continue; + break; + case OP_HI8: + if (addr_mode[i] == ST8_HI8) + continue; + break; + case OP_HH8: + if (addr_mode[i] == ST8_HH8) + continue; + break; case OP_ILLEGAL: as_fatal(_("BUG: OP_ILLEGAL")); return 1; @@ -989,22 +1102,22 @@ md_assemble (char *str) for(i = 0; opcode[i].name != NULL; i++) { if (!strcmp(op, opcode[i].name)) - if(!cmpspec(opcode[i].constraints, exps, count)) - { - int insn_size = stm8_compute_insn_size(opcode[i]); - char *frag = frag_more(insn_size); - 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)) + if(!cmpspec(opcode[i].constraints, exps, count)) { - count = -count; + int insn_size = stm8_compute_insn_size(opcode[i]); + char *frag = frag_more(insn_size); + 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; } - stm8_bfd_out(opcode[i], exps, count, frag); - break; - } } if(!opcode[i].name) as_bad("Invalid instruction: %s", str_orig); @@ -1028,7 +1141,7 @@ md_pcrel_from_section (fixS *fixp, segT sec) && (!S_IS_DEFINED (fixp->fx_addsy) || (S_GET_SEGMENT (fixp->fx_addsy) != sec))) return 0; - + return fixp->fx_size + fixp->fx_where + fixp->fx_frag->fr_address; //return fixp->fx_frag->fr_address+fixp->fx_frag->fr_fix; return fixp->fx_frag->fr_address + fixp->fx_where; diff --git a/gas/config/tc-stm8.h b/gas/config/tc-stm8.h index 066e72ea..45c94d69 100644 --- a/gas/config/tc-stm8.h +++ b/gas/config/tc-stm8.h @@ -40,7 +40,7 @@ /* You should define this macro to be non-zero if the target is big endian, and zero if the target is little endian. */ -#define TARGET_BYTES_BIG_ENDIAN 0 +#define TARGET_BYTES_BIG_ENDIAN 1 /* If you define this macro, GAS will warn about the use of nonstandard escape sequences in a string. */ diff --git a/include/elf/stm8.h b/include/elf/stm8.h index 4f703354..3468a575 100644 --- a/include/elf/stm8.h +++ b/include/elf/stm8.h @@ -33,6 +33,9 @@ START_RELOC_NUMBERS (elf_avr_reloc_type) RELOC_NUMBER (R_STM8_24, 3) RELOC_NUMBER (R_STM8_32, 4) RELOC_NUMBER (R_STM8_8_PCREL, 5) + RELOC_NUMBER (R_STM8_HI8, 6) + RELOC_NUMBER (R_STM8_LO8, 7) + RELOC_NUMBER (R_STM8_HH8, 8) END_RELOC_NUMBERS (R_STM8_max) #endif /* _ELF_STM_H */ diff --git a/include/opcode/stm8.h b/include/opcode/stm8.h index d131527d..18eb88a7 100644 --- a/include/opcode/stm8.h +++ b/include/opcode/stm8.h @@ -63,7 +63,10 @@ typedef enum { ST8_LONGPTRW_Y, ST8_LONGPTRE, ST8_LONGPTRE_X, - ST8_LONGPTRE_Y + ST8_LONGPTRE_Y, + ST8_HI8, + ST8_LO8, + ST8_HH8 } stm8_addr_mode_t; struct stm8_opcodes_s diff --git a/opcodes/stm8-dis.c b/opcodes/stm8-dis.c index 2eee6306..906b8370 100644 --- a/opcodes/stm8-dis.c +++ b/opcodes/stm8-dis.c @@ -332,6 +332,33 @@ int stm8_operands(char *s, unsigned char buf[], stm8_addr_mode_t arg) sprintf(s,"(0x%6.6x,Y)",val); return 3; break; + case ST8_HI8: + val = buf[0]; + sym = find_symbol(val); + if (sym) + sprintf(s,"hi8(#%s)",sym); + else + sprintf(s,"hi8(#0x%2.2x)",val); + return 2; + break; + case ST8_LO8: + val = buf[0]; + sym = find_symbol(val); + if (sym) + sprintf(s,"lo8(#%s)",sym); + else + sprintf(s,"lo8(#0x%2.2x)",val); + return 2; + break; + case ST8_HH8: + val = buf[0]; + sym = find_symbol(val); + if (sym) + sprintf(s,"hh8(#%s)",sym); + else + sprintf(s,"hh8(#0x%4.4x)",val); + return 3; + break; case ST8_END: break; } @@ -389,8 +416,8 @@ int stm8_dis(bfd_vma addr, unsigned int op) } } } - - + + // c = ' '; // for (j=0; j<5; j++, operand += dir) // { diff --git a/opcodes/stm8-opc.c b/opcodes/stm8-opc.c index 9516d859..d16e7b60 100644 --- a/opcodes/stm8-opc.c +++ b/opcodes/stm8-opc.c @@ -489,6 +489,9 @@ const struct stm8_opcodes_s stm8_opcodes[] = {"push", {ST8_REG_CC}, 0x8A}, {"push", {ST8_BYTE}, 0x4B}, {"push", {ST8_LONGMEM}, 0x3B}, +{"push", {ST8_HI8}, 0x4B}, +{"push", {ST8_LO8}, 0x4B}, +{"push", {ST8_HH8}, 0x4B}, //pushw {"pushw", {ST8_REG_X}, 0x89}, {"pushw", {ST8_REG_Y}, 0x9089}, @@ -759,6 +762,8 @@ int stm8_compute_insn_size(struct stm8_opcodes_s opcode) { case ST8_SHORTOFF_X: case ST8_SHORTOFF_Y: case ST8_SHORTOFF_SP: + case ST8_LO8: + case ST8_HI8: ret++; break; case ST8_LONGPTRE_Y: @@ -776,6 +781,7 @@ int stm8_compute_insn_size(struct stm8_opcodes_s opcode) { case ST8_EXTMEM: case ST8_EXTOFF_X: case ST8_EXTOFF_Y: + case ST8_HH8: ret += 3; break; case ST8_END: -- 2.17.1