Diff for /qemu/dyngen.c between versions 1.1.1.1 and 1.1.1.2

version 1.1.1.1, 2018/04/24 16:37:52 version 1.1.1.2, 2018/04/24 16:40:55
Line 1679  void gen_code(const char *name, host_ulo Line 1679  void gen_code(const char *name, host_ulo
 #endif                      #endif                    
                     if (val >= start_offset && val <= start_offset + copy_size) {                      if (val >= start_offset && val <= start_offset + copy_size) {
                         n = strtol(p, NULL, 10);                          n = strtol(p, NULL, 10);
                         fprintf(outfile, "    label_offsets[%d] = %ld + (gen_code_ptr - gen_code_buf);\n", n, val - start_offset);                          fprintf(outfile, "    label_offsets[%d] = %ld + (gen_code_ptr - gen_code_buf);\n", n, (long)(val - start_offset));
                     }                      }
                 }                  }
             }              }
Line 1696  void gen_code(const char *name, host_ulo Line 1696  void gen_code(const char *name, host_ulo
                 char name[256];                  char name[256];
                 int type;                  int type;
                 int addend;                  int addend;
                   int reloc_offset;
                 for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {                  for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {
                 if (rel->r_offset >= start_offset &&                  if (rel->r_offset >= start_offset &&
                     rel->r_offset < start_offset + copy_size) {                      rel->r_offset < start_offset + copy_size) {
                     sym_name = get_rel_sym_name(rel);                      sym_name = get_rel_sym_name(rel);
                     if (!sym_name)                      if (!sym_name)
                         continue;                          continue;
                       reloc_offset = rel->r_offset - start_offset;
                     if (strstart(sym_name, "__op_jmp", &p)) {                      if (strstart(sym_name, "__op_jmp", &p)) {
                         int n;                          int n;
                         n = strtol(p, NULL, 10);                          n = strtol(p, NULL, 10);
Line 1710  void gen_code(const char *name, host_ulo Line 1712  void gen_code(const char *name, host_ulo
                            chaining: the offset of the instruction                             chaining: the offset of the instruction
                            needs to be stored */                             needs to be stored */
                         fprintf(outfile, "    jmp_offsets[%d] = %d + (gen_code_ptr - gen_code_buf);\n",                          fprintf(outfile, "    jmp_offsets[%d] = %d + (gen_code_ptr - gen_code_buf);\n",
                                 n, rel->r_offset - start_offset);                                  n, reloc_offset);
                         continue;                          continue;
                     }                      }
                           
                     get_reloc_expr(name, sizeof(name), sym_name);                      get_reloc_expr(name, sizeof(name), sym_name);
                     addend = get32((uint32_t *)(text + rel->r_offset));                      addend = get32((uint32_t *)(text + rel->r_offset));
 #ifdef CONFIG_FORMAT_ELF  #ifdef CONFIG_FORMAT_ELF
Line 1721  void gen_code(const char *name, host_ulo Line 1723  void gen_code(const char *name, host_ulo
                     switch(type) {                      switch(type) {
                     case R_386_32:                      case R_386_32:
                         fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n",                           fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n", 
                                 rel->r_offset - start_offset, name, addend);                                  reloc_offset, name, addend);
                         break;                          break;
                     case R_386_PC32:                      case R_386_PC32:
                         fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s - (long)(gen_code_ptr + %d) + %d;\n",                           fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s - (long)(gen_code_ptr + %d) + %d;\n", 
                                 rel->r_offset - start_offset, name, rel->r_offset - start_offset, addend);                                  reloc_offset, name, reloc_offset, addend);
                         break;                          break;
                     default:                      default:
                         error("unsupported i386 relocation (%d)", type);                          error("unsupported i386 relocation (%d)", type);
Line 1748  void gen_code(const char *name, host_ulo Line 1750  void gen_code(const char *name, host_ulo
                     switch(type) {                      switch(type) {
                     case DIR32:                      case DIR32:
                         fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n",                           fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n", 
                                 rel->r_offset - start_offset, name, addend);                                  reloc_offset, name, addend);
                         break;                          break;
                     case DISP32:                      case DISP32:
                         fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s - (long)(gen_code_ptr + %d) + %d -4;\n",                           fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s - (long)(gen_code_ptr + %d) + %d -4;\n", 
                                 rel->r_offset - start_offset, name, rel->r_offset - start_offset, addend);                                  reloc_offset, name, reloc_offset, addend);
                         break;                          break;
                     default:                      default:
                         error("unsupported i386 relocation (%d)", type);                          error("unsupported i386 relocation (%d)", type);
Line 1768  void gen_code(const char *name, host_ulo Line 1770  void gen_code(const char *name, host_ulo
                 char name[256];                  char name[256];
                 int type;                  int type;
                 int addend;                  int addend;
                   int reloc_offset;
                 for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {                  for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {
                 if (rel->r_offset >= start_offset &&                  if (rel->r_offset >= start_offset &&
                     rel->r_offset < start_offset + copy_size) {                      rel->r_offset < start_offset + copy_size) {
Line 1775  void gen_code(const char *name, host_ulo Line 1778  void gen_code(const char *name, host_ulo
                     get_reloc_expr(name, sizeof(name), sym_name);                      get_reloc_expr(name, sizeof(name), sym_name);
                     type = ELF32_R_TYPE(rel->r_info);                      type = ELF32_R_TYPE(rel->r_info);
                     addend = rel->r_addend;                      addend = rel->r_addend;
                       reloc_offset = rel->r_offset - start_offset;
                     switch(type) {                      switch(type) {
                     case R_X86_64_32:                      case R_X86_64_32:
                         fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = (uint32_t)%s + %d;\n",                           fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = (uint32_t)%s + %d;\n", 
                                 rel->r_offset - start_offset, name, addend);                                  reloc_offset, name, addend);
                         break;                          break;
                     case R_X86_64_32S:                      case R_X86_64_32S:
                         fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = (int32_t)%s + %d;\n",                           fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = (int32_t)%s + %d;\n", 
                                 rel->r_offset - start_offset, name, addend);                                  reloc_offset, name, addend);
                         break;                          break;
                     case R_X86_64_PC32:                      case R_X86_64_PC32:
                         fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s - (long)(gen_code_ptr + %d) + %d;\n",                           fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s - (long)(gen_code_ptr + %d) + %d;\n", 
                                 rel->r_offset - start_offset, name, rel->r_offset - start_offset, addend);                                  reloc_offset, name, reloc_offset, addend);
                         break;                          break;
                     default:                      default:
                         error("unsupported X86_64 relocation (%d)", type);                          error("unsupported X86_64 relocation (%d)", type);
Line 1800  void gen_code(const char *name, host_ulo Line 1804  void gen_code(const char *name, host_ulo
                 char name[256];                  char name[256];
                 int type;                  int type;
                 int addend;                  int addend;
                   int reloc_offset;
                 for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {                  for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {
                     if (rel->r_offset >= start_offset &&                      if (rel->r_offset >= start_offset &&
                         rel->r_offset < start_offset + copy_size) {                          rel->r_offset < start_offset + copy_size) {
                         sym_name = strtab + symtab[ELFW(R_SYM)(rel->r_info)].st_name;                          sym_name = strtab + symtab[ELFW(R_SYM)(rel->r_info)].st_name;
                           reloc_offset = rel->r_offset - start_offset;
                         if (strstart(sym_name, "__op_jmp", &p)) {                          if (strstart(sym_name, "__op_jmp", &p)) {
                             int n;                              int n;
                             n = strtol(p, NULL, 10);                              n = strtol(p, NULL, 10);
Line 1812  void gen_code(const char *name, host_ulo Line 1818  void gen_code(const char *name, host_ulo
                                chaining: the offset of the instruction                                 chaining: the offset of the instruction
                                needs to be stored */                                 needs to be stored */
                             fprintf(outfile, "    jmp_offsets[%d] = %d + (gen_code_ptr - gen_code_buf);\n",                              fprintf(outfile, "    jmp_offsets[%d] = %d + (gen_code_ptr - gen_code_buf);\n",
                                     n, rel->r_offset - start_offset);                                      n, reloc_offset);
                             continue;                              continue;
                         }                          }
                                                   
Line 1822  void gen_code(const char *name, host_ulo Line 1828  void gen_code(const char *name, host_ulo
                         switch(type) {                          switch(type) {
                         case R_PPC_ADDR32:                          case R_PPC_ADDR32:
                             fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n",                               fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n", 
                                     rel->r_offset - start_offset, name, addend);                                      reloc_offset, name, addend);
                             break;                              break;
                         case R_PPC_ADDR16_LO:                          case R_PPC_ADDR16_LO:
                             fprintf(outfile, "    *(uint16_t *)(gen_code_ptr + %d) = (%s + %d);\n",                               fprintf(outfile, "    *(uint16_t *)(gen_code_ptr + %d) = (%s + %d);\n", 
                                     rel->r_offset - start_offset, name, addend);                                      reloc_offset, name, addend);
                             break;                              break;
                         case R_PPC_ADDR16_HI:                          case R_PPC_ADDR16_HI:
                             fprintf(outfile, "    *(uint16_t *)(gen_code_ptr + %d) = (%s + %d) >> 16;\n",                               fprintf(outfile, "    *(uint16_t *)(gen_code_ptr + %d) = (%s + %d) >> 16;\n", 
                                     rel->r_offset - start_offset, name, addend);                                      reloc_offset, name, addend);
                             break;                              break;
                         case R_PPC_ADDR16_HA:                          case R_PPC_ADDR16_HA:
                             fprintf(outfile, "    *(uint16_t *)(gen_code_ptr + %d) = (%s + %d + 0x8000) >> 16;\n",                               fprintf(outfile, "    *(uint16_t *)(gen_code_ptr + %d) = (%s + %d + 0x8000) >> 16;\n", 
                                     rel->r_offset - start_offset, name, addend);                                      reloc_offset, name, addend);
                             break;                              break;
                         case R_PPC_REL24:                          case R_PPC_REL24:
                             /* warning: must be at 32 MB distancy */                              /* warning: must be at 32 MB distancy */
                             fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = (*(uint32_t *)(gen_code_ptr + %d) & ~0x03fffffc) | ((%s - (long)(gen_code_ptr + %d) + %d) & 0x03fffffc);\n",                               fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = (*(uint32_t *)(gen_code_ptr + %d) & ~0x03fffffc) | ((%s - (long)(gen_code_ptr + %d) + %d) & 0x03fffffc);\n", 
                                     rel->r_offset - start_offset, rel->r_offset - start_offset, name, rel->r_offset - start_offset, addend);                                      reloc_offset, reloc_offset, name, reloc_offset, addend);
                             break;                              break;
                         default:                          default:
                             error("unsupported powerpc relocation (%d)", type);                              error("unsupported powerpc relocation (%d)", type);
Line 1941  void gen_code(const char *name, host_ulo Line 1947  void gen_code(const char *name, host_ulo
                 char name[256];                  char name[256];
                 int type;                  int type;
                 int addend;                  int addend;
                   int reloc_offset;
                 for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {                  for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {
                     if (rel->r_offset >= start_offset &&                      if (rel->r_offset >= start_offset &&
                         rel->r_offset < start_offset + copy_size) {                          rel->r_offset < start_offset + copy_size) {
Line 1948  void gen_code(const char *name, host_ulo Line 1955  void gen_code(const char *name, host_ulo
                         get_reloc_expr(name, sizeof(name), sym_name);                          get_reloc_expr(name, sizeof(name), sym_name);
                         type = ELF32_R_TYPE(rel->r_info);                          type = ELF32_R_TYPE(rel->r_info);
                         addend = rel->r_addend;                          addend = rel->r_addend;
                           reloc_offset = rel->r_offset - start_offset;
                         switch(type) {                          switch(type) {
                         case R_390_32:                          case R_390_32:
                             fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n",                               fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n", 
                                     rel->r_offset - start_offset, name, addend);                                      reloc_offset, name, addend);
                             break;                              break;
                         case R_390_16:                          case R_390_16:
                             fprintf(outfile, "    *(uint16_t *)(gen_code_ptr + %d) = %s + %d;\n",                               fprintf(outfile, "    *(uint16_t *)(gen_code_ptr + %d) = %s + %d;\n", 
                                     rel->r_offset - start_offset, name, addend);                                      reloc_offset, name, addend);
                             break;                              break;
                         case R_390_8:                          case R_390_8:
                             fprintf(outfile, "    *(uint8_t *)(gen_code_ptr + %d) = %s + %d;\n",                               fprintf(outfile, "    *(uint8_t *)(gen_code_ptr + %d) = %s + %d;\n", 
                                     rel->r_offset - start_offset, name, addend);                                      reloc_offset, name, addend);
                             break;                              break;
                         default:                          default:
                             error("unsupported s390 relocation (%d)", type);                              error("unsupported s390 relocation (%d)", type);
Line 1972  void gen_code(const char *name, host_ulo Line 1980  void gen_code(const char *name, host_ulo
                 for (i = 0, rel = relocs; i < nb_relocs; i++, rel++) {                  for (i = 0, rel = relocs; i < nb_relocs; i++, rel++) {
                     if (rel->r_offset >= start_offset && rel->r_offset < start_offset + copy_size) {                      if (rel->r_offset >= start_offset && rel->r_offset < start_offset + copy_size) {
                         int type;                          int type;
                           long reloc_offset;
   
                         type = ELF64_R_TYPE(rel->r_info);                          type = ELF64_R_TYPE(rel->r_info);
                         sym_name = strtab + symtab[ELF64_R_SYM(rel->r_info)].st_name;                          sym_name = strtab + symtab[ELF64_R_SYM(rel->r_info)].st_name;
                           reloc_offset = rel->r_offset - start_offset;
                         switch (type) {                          switch (type) {
                         case R_ALPHA_GPDISP:                          case R_ALPHA_GPDISP:
                             /* The gp is just 32 bit, and never changes, so it's easiest to emit it                              /* The gp is just 32 bit, and never changes, so it's easiest to emit it
                                as an immediate instead of constructing it from the pv or ra.  */                                 as an immediate instead of constructing it from the pv or ra.  */
                             fprintf(outfile, "    immediate_ldah(gen_code_ptr + %ld, gp);\n",                              fprintf(outfile, "    immediate_ldah(gen_code_ptr + %ld, gp);\n",
                                     rel->r_offset - start_offset);                                      reloc_offset);
                             fprintf(outfile, "    immediate_lda(gen_code_ptr + %ld, gp);\n",                              fprintf(outfile, "    immediate_lda(gen_code_ptr + %ld, gp);\n",
                                     rel->r_offset - start_offset + rel->r_addend);                                      reloc_offset + (int)rel->r_addend);
                             break;                              break;
                         case R_ALPHA_LITUSE:                          case R_ALPHA_LITUSE:
                             /* jsr to literal hint. Could be used to optimize to bsr. Ignore for                              /* jsr to literal hint. Could be used to optimize to bsr. Ignore for
Line 2002  void gen_code(const char *name, host_ulo Line 2012  void gen_code(const char *name, host_ulo
                                special treatment.  */                                 special treatment.  */
                             if (strstart(sym_name, "__op_param", &p))                              if (strstart(sym_name, "__op_param", &p))
                                 fprintf(outfile, "    immediate_ldah(gen_code_ptr + %ld, param%s);\n",                                  fprintf(outfile, "    immediate_ldah(gen_code_ptr + %ld, param%s);\n",
                                         rel->r_offset - start_offset, p);                                          reloc_offset, p);
                             break;                              break;
                         case R_ALPHA_GPRELLOW:                          case R_ALPHA_GPRELLOW:
                             if (strstart(sym_name, "__op_param", &p))                              if (strstart(sym_name, "__op_param", &p))
                                 fprintf(outfile, "    immediate_lda(gen_code_ptr + %ld, param%s);\n",                                  fprintf(outfile, "    immediate_lda(gen_code_ptr + %ld, param%s);\n",
                                         rel->r_offset - start_offset, p);                                          reloc_offset, p);
                             break;                              break;
                         case R_ALPHA_BRSGP:                          case R_ALPHA_BRSGP:
                             /* PC-relative jump. Tweak offset to skip the two instructions that try to                              /* PC-relative jump. Tweak offset to skip the two instructions that try to
                                set up the gp from the pv.  */                                 set up the gp from the pv.  */
                             fprintf(outfile, "    fix_bsr(gen_code_ptr + %ld, (uint8_t *) &%s - (gen_code_ptr + %ld + 4) + 8);\n",                              fprintf(outfile, "    fix_bsr(gen_code_ptr + %ld, (uint8_t *) &%s - (gen_code_ptr + %ld + 4) + 8);\n",
                                     rel->r_offset - start_offset, sym_name, rel->r_offset - start_offset);                                      reloc_offset, sym_name, reloc_offset);
                             break;                              break;
                         default:                          default:
                             error("unsupported Alpha relocation (%d)", type);                              error("unsupported Alpha relocation (%d)", type);
Line 2035  void gen_code(const char *name, host_ulo Line 2045  void gen_code(const char *name, host_ulo
                         || rel->r_offset >= start_offset + copy_size)                          || rel->r_offset >= start_offset + copy_size)
                         continue;                          continue;
                     sym_name = (strtab + symtab[sym_idx].st_name);                      sym_name = (strtab + symtab[sym_idx].st_name);
                       code_offset = rel->r_offset - start_offset;
                     if (strstart(sym_name, "__op_jmp", &p)) {                      if (strstart(sym_name, "__op_jmp", &p)) {
                         int n;                          int n;
                         n = strtol(p, NULL, 10);                          n = strtol(p, NULL, 10);
Line 2044  void gen_code(const char *name, host_ulo Line 2055  void gen_code(const char *name, host_ulo
                            needs to be stored */                             needs to be stored */
                         fprintf(outfile, "    jmp_offsets[%d] ="                          fprintf(outfile, "    jmp_offsets[%d] ="
                                 "%ld + (gen_code_ptr - gen_code_buf);\n",                                  "%ld + (gen_code_ptr - gen_code_buf);\n",
                                 n, rel->r_offset - start_offset);                                  n, code_offset);
                         continue;                          continue;
                     }                      }
                     get_reloc_expr(name, sizeof(name), sym_name);                      get_reloc_expr(name, sizeof(name), sym_name);
                     type = ELF64_R_TYPE(rel->r_info);                      type = ELF64_R_TYPE(rel->r_info);
                     addend = rel->r_addend;                      addend = rel->r_addend;
                     code_offset = rel->r_offset - start_offset;  
                     switch(type) {                      switch(type) {
                       case R_IA64_IMM64:                        case R_IA64_IMM64:
                           fprintf(outfile,                            fprintf(outfile,
Line 2101  void gen_code(const char *name, host_ulo Line 2111  void gen_code(const char *name, host_ulo
                 char name[256];                  char name[256];
                 int type;                  int type;
                 int addend;                  int addend;
                   int reloc_offset;
                 for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {                  for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {
                     if (rel->r_offset >= start_offset &&                      if (rel->r_offset >= start_offset &&
                         rel->r_offset < start_offset + copy_size) {                          rel->r_offset < start_offset + copy_size) {
Line 2108  void gen_code(const char *name, host_ulo Line 2119  void gen_code(const char *name, host_ulo
                         get_reloc_expr(name, sizeof(name), sym_name);                          get_reloc_expr(name, sizeof(name), sym_name);
                         type = ELF32_R_TYPE(rel->r_info);                          type = ELF32_R_TYPE(rel->r_info);
                         addend = rel->r_addend;                          addend = rel->r_addend;
                           reloc_offset = rel->r_offset - start_offset;
                         switch(type) {                          switch(type) {
                         case R_SPARC_32:                          case R_SPARC_32:
                             fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n",                               fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n", 
                                     rel->r_offset - start_offset, name, addend);                                      reloc_offset, name, addend);
                             break;                              break;
                         case R_SPARC_HI22:                          case R_SPARC_HI22:
                             fprintf(outfile,                              fprintf(outfile,
Line 2119  void gen_code(const char *name, host_ulo Line 2131  void gen_code(const char *name, host_ulo
                                     "((*(uint32_t *)(gen_code_ptr + %d)) "                                      "((*(uint32_t *)(gen_code_ptr + %d)) "
                                     " & ~0x3fffff) "                                      " & ~0x3fffff) "
                                     " | (((%s + %d) >> 10) & 0x3fffff);\n",                                      " | (((%s + %d) >> 10) & 0x3fffff);\n",
                                     rel->r_offset - start_offset,                                      reloc_offset, reloc_offset, name, addend);
                                     rel->r_offset - start_offset,  
                                     name, addend);  
                             break;                              break;
                         case R_SPARC_LO10:                          case R_SPARC_LO10:
                             fprintf(outfile,                              fprintf(outfile,
Line 2129  void gen_code(const char *name, host_ulo Line 2139  void gen_code(const char *name, host_ulo
                                     "((*(uint32_t *)(gen_code_ptr + %d)) "                                      "((*(uint32_t *)(gen_code_ptr + %d)) "
                                     " & ~0x3ff) "                                      " & ~0x3ff) "
                                     " | ((%s + %d) & 0x3ff);\n",                                      " | ((%s + %d) & 0x3ff);\n",
                                     rel->r_offset - start_offset,                                      reloc_offset, reloc_offset, name, addend);
                                     rel->r_offset - start_offset,  
                                     name, addend);  
                             break;                              break;
                         case R_SPARC_WDISP30:                          case R_SPARC_WDISP30:
                             fprintf(outfile,                              fprintf(outfile,
Line 2140  void gen_code(const char *name, host_ulo Line 2148  void gen_code(const char *name, host_ulo
                                     " & ~0x3fffffff) "                                      " & ~0x3fffffff) "
                                     " | ((((%s + %d) - (long)(gen_code_ptr + %d))>>2) "                                      " | ((((%s + %d) - (long)(gen_code_ptr + %d))>>2) "
                                     "    & 0x3fffffff);\n",                                      "    & 0x3fffffff);\n",
                                     rel->r_offset - start_offset,                                      reloc_offset, reloc_offset, name, addend,
                                     rel->r_offset - start_offset,                                      reloc_offset);
                                     name, addend,  
                                     rel->r_offset - start_offset);  
                             break;                              break;
                         default:                          default:
                             error("unsupported sparc relocation (%d)", type);                              error("unsupported sparc relocation (%d)", type);
Line 2156  void gen_code(const char *name, host_ulo Line 2162  void gen_code(const char *name, host_ulo
                 char name[256];                  char name[256];
                 int type;                  int type;
                 int addend;                  int addend;
                   int reloc_offset;
                 for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {                  for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {
                     if (rel->r_offset >= start_offset &&                      if (rel->r_offset >= start_offset &&
                         rel->r_offset < start_offset + copy_size) {                          rel->r_offset < start_offset + copy_size) {
Line 2163  void gen_code(const char *name, host_ulo Line 2170  void gen_code(const char *name, host_ulo
                         get_reloc_expr(name, sizeof(name), sym_name);                          get_reloc_expr(name, sizeof(name), sym_name);
                         type = ELF64_R_TYPE(rel->r_info);                          type = ELF64_R_TYPE(rel->r_info);
                         addend = rel->r_addend;                          addend = rel->r_addend;
                           reloc_offset = rel->r_offset - start_offset;
                         switch(type) {                          switch(type) {
                         case R_SPARC_32:                          case R_SPARC_32:
                             fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n",                              fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n",
                                     rel->r_offset - start_offset, name, addend);                                      reloc_offset, name, addend);
                             break;                              break;
                         case R_SPARC_HI22:                          case R_SPARC_HI22:
                             fprintf(outfile,                              fprintf(outfile,
Line 2174  void gen_code(const char *name, host_ulo Line 2182  void gen_code(const char *name, host_ulo
                                     "((*(uint32_t *)(gen_code_ptr + %d)) "                                      "((*(uint32_t *)(gen_code_ptr + %d)) "
                                     " & ~0x3fffff) "                                      " & ~0x3fffff) "
                                     " | (((%s + %d) >> 10) & 0x3fffff);\n",                                      " | (((%s + %d) >> 10) & 0x3fffff);\n",
                                     rel->r_offset - start_offset,                                      reloc_offset, reloc_offset, name, addend);
                                     rel->r_offset - start_offset,  
                                     name, addend);  
                             break;                              break;
                         case R_SPARC_LO10:                          case R_SPARC_LO10:
                             fprintf(outfile,                              fprintf(outfile,
Line 2184  void gen_code(const char *name, host_ulo Line 2190  void gen_code(const char *name, host_ulo
                                     "((*(uint32_t *)(gen_code_ptr + %d)) "                                      "((*(uint32_t *)(gen_code_ptr + %d)) "
                                     " & ~0x3ff) "                                      " & ~0x3ff) "
                                     " | ((%s + %d) & 0x3ff);\n",                                      " | ((%s + %d) & 0x3ff);\n",
                                     rel->r_offset - start_offset,                                      reloc_offset, reloc_offset, name, addend);
                                     rel->r_offset - start_offset,  
                                     name, addend);  
                             break;                              break;
                         case R_SPARC_WDISP30:                          case R_SPARC_WDISP30:
                             fprintf(outfile,                              fprintf(outfile,
Line 2195  void gen_code(const char *name, host_ulo Line 2199  void gen_code(const char *name, host_ulo
                                     " & ~0x3fffffff) "                                      " & ~0x3fffffff) "
                                     " | ((((%s + %d) - (long)(gen_code_ptr + %d))>>2) "                                      " | ((((%s + %d) - (long)(gen_code_ptr + %d))>>2) "
                                     "    & 0x3fffffff);\n",                                      "    & 0x3fffffff);\n",
                                     rel->r_offset - start_offset,                                      reloc_offset, reloc_offset, name, addend,
                                     rel->r_offset - start_offset,                                      reloc_offset);
                                     name, addend,  
                                     rel->r_offset - start_offset);  
                             break;                              break;
                         default:                          default:
                             error("unsupported sparc64 relocation (%d)", type);                              error("unsupported sparc64 relocation (%d)", type);
Line 2211  void gen_code(const char *name, host_ulo Line 2213  void gen_code(const char *name, host_ulo
                 char name[256];                  char name[256];
                 int type;                  int type;
                 int addend;                  int addend;
                   int reloc_offset;
   
                 arm_emit_ldr_info(name, start_offset, outfile, p_start, p_end,                  arm_emit_ldr_info(name, start_offset, outfile, p_start, p_end,
                                   relocs, nb_relocs);                                    relocs, nb_relocs);
Line 2225  void gen_code(const char *name, host_ulo Line 2228  void gen_code(const char *name, host_ulo
                     get_reloc_expr(name, sizeof(name), sym_name);                      get_reloc_expr(name, sizeof(name), sym_name);
                     type = ELF32_R_TYPE(rel->r_info);                      type = ELF32_R_TYPE(rel->r_info);
                     addend = get32((uint32_t *)(text + rel->r_offset));                      addend = get32((uint32_t *)(text + rel->r_offset));
                       reloc_offset = rel->r_offset - start_offset;
                     switch(type) {                      switch(type) {
                     case R_ARM_ABS32:                      case R_ARM_ABS32:
                         fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n",                           fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n", 
                                 rel->r_offset - start_offset, name, addend);                                  reloc_offset, name, addend);
                         break;                          break;
                     case R_ARM_PC24:                      case R_ARM_PC24:
                         fprintf(outfile, "    arm_reloc_pc24((uint32_t *)(gen_code_ptr + %d), 0x%x, %s);\n",                           fprintf(outfile, "    arm_reloc_pc24((uint32_t *)(gen_code_ptr + %d), 0x%x, %s);\n", 
                                 rel->r_offset - start_offset, addend, name);                                  reloc_offset, addend, name);
                         break;                          break;
                     default:                      default:
                         error("unsupported arm relocation (%d)", type);                          error("unsupported arm relocation (%d)", type);
Line 2245  void gen_code(const char *name, host_ulo Line 2249  void gen_code(const char *name, host_ulo
                 char name[256];                  char name[256];
                 int type;                  int type;
                 int addend;                  int addend;
                   int reloc_offset;
                 Elf32_Sym *sym;                  Elf32_Sym *sym;
                 for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {                  for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {
                 if (rel->r_offset >= start_offset &&                  if (rel->r_offset >= start_offset &&
Line 2254  void gen_code(const char *name, host_ulo Line 2259  void gen_code(const char *name, host_ulo
                     get_reloc_expr(name, sizeof(name), sym_name);                      get_reloc_expr(name, sizeof(name), sym_name);
                     type = ELF32_R_TYPE(rel->r_info);                      type = ELF32_R_TYPE(rel->r_info);
                     addend = get32((uint32_t *)(text + rel->r_offset)) + rel->r_addend;                      addend = get32((uint32_t *)(text + rel->r_offset)) + rel->r_addend;
                       reloc_offset = rel->r_offset - start_offset;
                     switch(type) {                      switch(type) {
                     case R_68K_32:                      case R_68K_32:
                         fprintf(outfile, "    /* R_68K_32 RELOC, offset %x */\n", rel->r_offset) ;                          fprintf(outfile, "    /* R_68K_32 RELOC, offset %x */\n", rel->r_offset) ;
                         fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %#x;\n",                           fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %#x;\n", 
                                 rel->r_offset - start_offset, name, addend );                                  reloc_offset, name, addend );
                         break;                          break;
                     case R_68K_PC32:                      case R_68K_PC32:
                         fprintf(outfile, "    /* R_68K_PC32 RELOC, offset %x */\n", rel->r_offset);                          fprintf(outfile, "    /* R_68K_PC32 RELOC, offset %x */\n", rel->r_offset);
                         fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s - (long)(gen_code_ptr + %#x) + %#x;\n",                           fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s - (long)(gen_code_ptr + %#x) + %#x;\n", 
                                 rel->r_offset - start_offset, name, rel->r_offset - start_offset, /*sym->st_value+*/ addend);                                  reloc_offset, name, reloc_offset, /*sym->st_value+*/ addend);
                         break;                          break;
                     default:                      default:
                         error("unsupported m68k relocation (%d)", type);                          error("unsupported m68k relocation (%d)", type);
Line 2469  fprintf(outfile, Line 2475  fprintf(outfile,
 );  );
 #ifdef HOST_IA64  #ifdef HOST_IA64
     fprintf(outfile,      fprintf(outfile,
             "    ia64_apply_fixes(&gen_code_ptr, ltoff_fixes, "              "    {\n"
               "      extern char code_gen_buffer[];\n"
               "      ia64_apply_fixes(&gen_code_ptr, ltoff_fixes, "
             "(uint64_t) code_gen_buffer + 2*(1<<20), plt_fixes,\n\t\t\t"              "(uint64_t) code_gen_buffer + 2*(1<<20), plt_fixes,\n\t\t\t"
             "sizeof(plt_target)/sizeof(plt_target[0]),\n\t\t\t"              "sizeof(plt_target)/sizeof(plt_target[0]),\n\t\t\t"
             "plt_target, plt_offset);\n");              "plt_target, plt_offset);\n    }\n");
 #endif  #endif
   
 /* generate some code patching */   /* generate some code patching */ 

Removed from v.1.1.1.1  
changed lines
  Added in v.1.1.1.2


unix.superglobalmegacorp.com