User Tag List

Показано с 1 по 10 из 111

Тема: Кросскомпилятор Си под 8080

Древовидный режим

Предыдущее сообщение Предыдущее сообщение   Следующее сообщение Следующее сообщение
  1. #19

    Регистрация
    01.12.2010
    Адрес
    г. Санкт-Петербург
    Сообщений
    1,657
    Записей в дневнике
    21
    Спасибо Благодарностей отдано 
    0
    Спасибо Благодарностей получено 
    3
    Поблагодарили
    2 сообщений
    Mentioned
    0 Post(s)
    Tagged
    0 Thread(s)

    По умолчанию

    Вот это это выглядит. Код для 8 битного вычитания.

    Для команд & | ^ + > < <= >= != == будет подобный вариант, но там команды будут проще, так как там слогаемые можно переставлять:

    case pC, pA: w.ld_d_a().ld_a_c().alu_d(op); break;

    заменится на

    case pC, pA: w.alu_с(op); break;

    Код:
    void cmd_alu(AluOp op, bool self, bool flags) {
      Stack& a = stack[stack.size()-2];
      Stack& b = stack[stack.size()-1];
    
      Place ap = simpleArg8(a.place);
      Place bp = simpleArg8(b.place);
    
      Writer& w = bc();
    
      if(ap!=pA && bp!=pA) 
        useA();
    
      switch(ap) {
        case pA:
          switch(bp) {
            case pB:                          w.alu_b(op); break;
            case pC:                          w.alu_c(op); break;
            case pHL:                         w.alu_l(op); break;
            case pConst:                      w.alu(op, b); break;
            case pConstRef8:         useHL(); w.ld_hl(b).alu_HL(op); break;
            case pConstStrRefRef8:   useHL(); w.ld_hl_ref(b).alu_HL(op); break;
            case pHLRef8:                     w.alu_HL(op); break;
            case pBCRef8:            useHL(); w.ld_hl_bc().alu_HL(op); break;
            case pStack8:                     w.pop_de().alu_d(op); break;
            case pStack16:                    w.pop_de().alu_e(op); break;
            case pStackRef8:         chkHL(); w.pop_hl().alu_HL(op); break;
            default: cmd_alu_raise(ap, bp);
          }
          break;
        case pB:
          switch(bp) {
            case pA:                          w.ld_d_a().ld_a_b().alu_d(op); break;
            case pB:                          w.ld_a_b().alu_b(op); break;
            case pC:                          w.ld_a_b().alu_c(op); break;
            case pHL:                         w.ld_a_b().alu_l(op); break;
            case pConst:                      w.ld_a_b().alu(op, b); break;
            case pConstRef8:                  w.ld_a_b().ld_hl(b).alu_HL(op); break;
            case pConstStrRefRef8:   useHL(); w.ld_a_b().ld_hl_ref(b).alu_HL(op); break;
            case pHLRef8:                     w.ld_a_b().alu_HL(op); break;
            case pBCRef8:                     w.ld_a_BC().ld_d_a().ld_a_b().alu_d(op); break;
            default: cmd_alu_raise(ap, bp);
          }
          break;
        case pC:
          switch(bp) {
            case pA:                          w.ld_d_a().ld_a_c().alu_d(op); break;
            case pB:                          w.ld_a_c().alu_b(op); break;
            case pC:                          w.ld_a_c().alu_c(op); break;
            case pHL:                         w.ld_a_c().alu_l(op); break;
            case pConst:                      w.ld_a_c().alu(op, b); break;
            case pConstRef8:                  w.ld_a_c().ld_hl(b).alu_HL(op); break;
            case pConstStrRefRef8:   useHL(); w.ld_a_c().ld_hl_ref(b).alu_HL(op); break;
            case pHLRef8:                     w.ld_a_c().alu_HL(op); break;
            case pBCRef8:                     w.ld_a_BC().ld_d_a().ld_a_b().alu_d(op); break;
            default: cmd_alu_raise(ap, bp);
          }
          break;
        case pHL:
          switch(bp) {
            case pA:                          w.ld_d_a().ld_a_l().alu_d(op); break;
            case pB:                          w.ld_a_l().alu_b(op); break;
            case pC:                          w.ld_a_l().alu_c(op); break;
            case pConst:                      w.ld_a_l().alu(op, b); break;
            case pConstRef8:                  w.ld_a_l().ld_hl(b).alu_HL(op); break;
            case pConstStrRefRef8:            w.ld_a_l().ld_hl_ref(b).alu_HL(op); break;
            case pBCRef8:                     w.ld_a_BC().ld_d_a().ld_a_l().alu_d(op); break;
            default: cmd_alu_raise(ap, bp);
          }
          break;
        case pConst:
          switch(bp) {
            case pA:                          w.ld_d_a().ld_a(a).alu_d(op); break;
            case pB:                          w.ld_a(a).alu_b(op); break;
            case pC:                          w.ld_a(a).alu_c(op); break;
            case pHL:                         w.ld_a(a).alu_l(op); break;
            case pConstRef8: if(lastHL==-1) { w.ld_hl(b).ld_a(a).alu_HL(op); break; } // 10+7+7=24 
                                              w.ld_a_ref(b).ld_d_a().ld_a(a).alu_d(op); break; // 13+5+7+7=32
            case pConstStrRefRef8:   useHL(); w.ld_hl_ref(b).ld_a(a).alu_HL(op); break;
            case pHLRef8:                     w.ld_a(a).alu_HL(op); break;
            case pBCRef8:                     w.ld_a_BC().ld_d_a().ld_a(a).alu_d(op); break; // это 7+5+7+4=23, против ld_hl_bc().ld_a(a).alu_HL(op), которым еще нужен HL
            default: cmd_alu_raise(ap, bp);
          }
          break;
        case pConstRef8:
          switch(bp) {
            case pA:                          w.ld_d_a().ld_a_ref(a).alu_d(op); break;
            case pB:                          w.ld_a_ref(a).alu_b(op); break;
            case pC:                          w.ld_a_ref(a).alu_c(op); break;
            case pHL:                         w.ld_a_ref(a).alu_l(op); break;
            case pConst:                      w.ld_a_ref(a).alu(op, b); break;
            case pConstRef8: if(lastHL==-1) { w.ld_hl(b).ld_a_ref(a).alu_HL(op); break; } // 10+13+7=30
                                              w.ld_a_ref(b).ld_d_a().ld_a_ref(a).alu_d(op); break; // 13+5+13+4=35
            case pConstStrRefRef8:   useHL(); w.ld_hl_ref(b).ld_a_ref(a).alu_HL(op); break; // 16+13+7=36
            case pHLRef8:                     w.ld_a_ref(a).alu_HL(op); break;
            case pBCRef8:                     w.ld_a_BC().ld_d_a().ld_a_ref(a).alu_d(op); break;
            default: cmd_alu_raise(ap, bp);
          }
          break;
        case pConstStrRefRef8:
          switch(bp) {
            case  pA:               useHL(); w.ld_d_a()                         .ld_hl_ref(a).ld_a_HL().alu_d(op); break;
            case  pB:               useHL(); w                                  .ld_hl_ref(a).ld_a_HL().alu_b(op); break;
            case  pC:               useHL(); w                                  .ld_hl_ref(a).ld_a_HL().alu_c(op); break;
            case  pHL:                       w.ld_d_l()                         .ld_hl_ref(a).ld_a_HL().alu_d(op); break;
            case  pConst:           useHL(); w                                  .ld_hl_ref(a).ld_a_HL().alu(op,b); break;
            case  pConstRef8:       useHL(); if(self) { w.ld_hl(a)    .ld_d_HL().ld_hl_ref(a).ld_a_HL().alu_d(op); break; } // 10+7+16+7+4 = 44
                                    w.ld_hl_ref(a).ld_a_HL().ld_hl(b).alu_HL(op); break;                                    // 16+7+10+7   = 40
            case  pConstStrRefRef8: useHL(); if(self) { w.ld_hl_ref(a).ld_d_HL().ld_hl_ref(a).ld_a_HL().alu_d(op); break; } // 16+7+16+7+4 = 50
                                    w.ld_hl_ref(a).ld_a_HL().ld_hl_ref(b).alu_HL(op); break;                                // 16+7+16+7   = 46
            case  pHLRef8:                   w.ld_d_HL()                        .ld_hl_ref(a).ld_a_HL().alu_d(op); break;
            case  pBCRef8:          useHL(); w.ld_a_BC().ld_d_a()               .ld_hl_ref(a).ld_a_HL().alu_d(op); break;
            default: cmd_alu_raise(ap, bp);
          }
          a.place = a.place==pConstStrRefRef8 ? pHLRef8 : pHLRef16; // Оптимизация
          lastHL = stack.size()-2;
          break;
        case pHLRef8: // Если self, то HL изменять нельзя
          switch(bp) {
            case pA:                        w.ld_d_a()              .ld_a_HL().alu_d(op); break;
            case pB:                        w                       .ld_a_HL().alu_b(op); break;
            case pC:                        w                       .ld_a_HL().alu_c(op); break;
            case pConst:                    w                       .ld_a_HL().alu(op,b); break;
            case pConstRef8:                w.ld_a_ref(b).ld_d_a()  .ld_a_HL(); break;
            case pConstStrRefRef8:if(self){ w.ex_hl_de().ld_hl_ref(b).ld_h_HL().ex_hl_de().ld_a_HL().alu_d(op); break; }
                                            w.ld_a_HL().ld_hl_ref(b).alu_HL(op); break;
            case pBCRef8:                   w.ld_a_BC().ld_d_a()    .ld_a_HL().alu_d(op); break;
            default: cmd_alu_raise(ap, bp);
          }
          break;
        case pBCRef8:
          switch(bp) {
            case pA:                        w.ld_d_a()              .ld_a_BC().alu_d(op);  break;
            case pB:                        w                       .ld_a_BC().alu_b(op);  break;
            case pC:                        w                       .ld_a_BC().alu_c(op);  break;
            case pHL:                       w                       .ld_a_BC().alu_l(op);  break;
            case pConst:                    w                       .ld_a_BC().alu(op,b);  break;
            case pConstRef8:if(lastHL==-1){ w.ld_hl(b)              .ld_a_BC().alu_HL(op); break; } // 10+7+7 = 24
                                            w.ld_a_ref(b).ld_d_a()  .ld_a_BC().alu_d(op);  break; // 13+5+7+4 = 29                             
            case pConstStrRefRef8: useHL(); w.ld_hl_ref(b)          .ld_a_BC().alu_HL(op); break;
    .... Съедено сайтом ...
        default: cmd_alu_raise(ap, bp);
      }
      if(self) {
        switch(a.place) {
          case pConstStrRef8:
          case pConstRef8: w.ld_ref_a(a); break;
          case pHLRef8:    w.ld_HL_a();   break;
          case pBCRef8:    w.ld_BC_a();   break;
          default: cmd_alu_self_raise(a.place, bp);
        }
        asm_pop();
        if(flags) raise("flags!");
      } else {
        asm_pop();
        asm_pop();
        if(flags) stack.push_backr().place = pFlags;
             else popTmpA();
      }
    }
    Последний раз редактировалось vinxru; 21.09.2012 в 23:34.

Информация о теме

Пользователи, просматривающие эту тему

Эту тему просматривают: 1 (пользователей: 0 , гостей: 1)

Похожие темы

  1. Ассемблер 8080
    от Kakos_nonos в разделе Утилиты
    Ответов: 0
    Последнее: 21.09.2011, 23:35
  2. Продам пару платок с процами 8080
    от RedLine в разделе Барахолка (архив)
    Ответов: 15
    Последнее: 23.12.2010, 18:39
  3. схема АОН на 8080/z80
    от sergey2b в разделе Разный софт
    Ответов: 7
    Последнее: 07.02.2010, 22:43
  4. An 8080/Z80 C Compiler
    от breeze в разделе Программирование
    Ответов: 1
    Последнее: 18.08.2005, 06:54

Ваши права

  • Вы не можете создавать новые темы
  • Вы не можете отвечать в темах
  • Вы не можете прикреплять вложения
  • Вы не можете редактировать свои сообщения
  •