Zobrazit příspěvky

Tato sekce Vám umožňuje zobrazit všechny příspěvky tohoto uživatele. Prosím uvědomte si, že můžete vidět příspěvky pouze z oblastí Vám přístupných.

Příspěvky - mhi

Stran: 1 [2] 3 4 ... 33

Vývoj / Re:Tester x86 (zejm.) ALU instrukcí

« kdy: 24. 06. 2023, 11:51:55 »

Dekuji za odpovedi,

ad qemu: tam toho zase tak moc nevidim, nejzajimavejsi je asi toto https://github.com/qemu/qemu/blob/master/tests/tcg/i386/test-i386.c - jenze to neresi uplne muj problem, potrebuju intenzivnejsi testy. Prusvih jsou takove ty ruzne drobnosti typu ze nejaka instrukce nastavuje nebo nenastavuje flagy, obcas se treba parity flag pouziva na neco obskurniho, apod. (ne ze bych tohle zrovna potreboval, to se v mem prekladanem kodu nebude vyskytovat, je to jen priklad).

ad bruteforce: pokud udelam skutecne bruteforce, tak to bude neskutecne dlouhe. Dlouhe to bude i kdyz omezim sady tech imm konstant a vstupu. Po precteni mne napadlo jeste udelat random testsuite, ze by to generovalo pseudonahodne ruzne testovaci sady (zkusime co udela adc nad signed pos a neg 8bit cislem, a pak zkusime jestli jnX bude fungovat vzdy stejne (a preskocime podminene dalsi testovaci pseudorandom kod).

Jinak tohle je reset kod pocitace TNS HC16:

Kód: [Vybrat]

seg000:E104 reset_routine   proc near
seg000:E104                 sub     ax, [bx+si]
seg000:E106
seg000:E106 loc_FE106:                              ; CODE XREF: int9_irq1_kbd+100
seg000:E106                 cli
seg000:E107                 cld
seg000:E108                 xor     ax, ax
seg000:E10A                 sahf
seg000:E10B                 jb      short err01
seg000:E10D                 jz      short err01
seg000:E10F                 jp      short err01
seg000:E111                 js      short err01
seg000:E113                 daa
seg000:E114                 or      al, al
seg000:E116                 jnz     short err01
seg000:E118                 not     ah
seg000:E11A                 sahf
seg000:E11B                 jnb     short err01
seg000:E11D                 jnz     short err01
seg000:E11F                 jnp     short err01
seg000:E121                 jns     short err01
seg000:E123                 daa
seg000:E124                 cmp     al, 66h ; 'f'
seg000:E126                 jnz     short err01
seg000:E128                 mov     ax, 5555h
seg000:E12B                 cmp     al, ah
seg000:E12D                 jnz     short err01
seg000:E12F                 shl     al, 1
seg000:E131                 or      al, ah
seg000:E133                 cmp     al, 0FFh
seg000:E135                 jnz     short err01
seg000:E137                 mov     ah, al
seg000:E139
seg000:E139 loc_FE139:                              ; CODE XREF: reset_routine+4Fj
seg000:E139                 mov     ds, ax
seg000:E13B                 mov     bx, ds
seg000:E13D                 mov     es, bx
seg000:E13F                 mov     cx, es
seg000:E141                 mov     ss, cx
seg000:E143                 mov     dx, ss
seg000:E145                 mov     sp, dx
seg000:E147                 mov     bp, sp
seg000:E149                 mov     si, bp
seg000:E14B                 mov     di, si
seg000:E14D                 sub     ax, di
seg000:E14F                 jnz     short err01
seg000:E151                 shl     cx, 1
seg000:E153                 jnb     short loc_FE139
seg000:E155                 jmp     short loc_FE159
seg000:E155 ; ---------------------------------------------------------------------------
seg000:E157                 db  90h ; É
seg000:E158 ; ---------------------------------------------------------------------------
seg000:E158
seg000:E158 err01:                                  ; CODE XREF: reset_routine+7j
seg000:E158                                         ; reset_routine+9j ...
seg000:E158                 hlt

Vývoj / Tester x86 (zejm.) ALU instrukcí

« kdy: 23. 06. 2023, 15:11:30 »

Doporucite mi prosim nekdo nejaky blob na testovani x86 emulatoru (translatoru), aby to umelo v idealni podobe:

- otestovat oddelene 16 a 32bit ruzne ALU operace (tzn. aby slo testovat jen 80(1,2)86 sadu) - na spravny vypocet
- to same na SPRAVNOU praci s flagy
- otestovat ruzne silenosti typu https://www.timdbg.com/posts/useless-x86-trivia/
- otestovat ruzne dalsi instrukce pro pametove operace, opet oddelene 16 (80(1)86) a 32bit (386+) rezim

Jde mi primarne skutecne jen o ALU. Znam treba https://github.com/barotto/test386.asm - takhle presne si to nejak predstavuju, tam bohuzel to ALU +/- chybi.

Doplnujici otazka - potrebuju neco podobneho i na jine sady, konkretne PowerPC a TriCore, 8051, 80166, Z80. Opet primarne zamerene na ALU, nepotrebuju zadne veci jako testy MMU apod.

Po minulych zkusenostech se nezlobte, ale na reakce rikajici mi ze delam blbost nebo ze to mam udelat jinak (pokud to nebude z meho pohledu dobry napad) nebudu vubec reagovat.

Distribuce / Re:Jak dostat vlastní software do oficiálních repozitářů?

« kdy: 14. 05. 2023, 20:15:51 »

Mam v Debianu vice balicku, teda alespon se zda, o nic jsem se ale nesnazil, neco jsem udelal myslim debian friendly a udelal definice pro zabalickovani - a nejak se to do Debianu dostalo.

Nevim, zda to je odpoved na otazku.

Vývoj / Re:C pre-preprocesor

« kdy: 20. 04. 2023, 12:22:33 »

Tohle forum je opravdu zajimave. Clovek si tak rika, jestli autor prispevku vubec cetl na co reaguje.

Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.

RDa: oddeleni pomoci newline mam, sice trosku jinak, ale ano, takhle to delam. Mne jde skutecne jen o tu indentaci. Staci si (napr.) v IDA otevrit defacto jakoukoliv binarku se slozitejsim optimalizovanym algoritmem (nejake zanorene cykly a if-y v sobe) a k tomu se zamyslet nad indentacnimi pravidly. Primitivni pravidlo ze telo kazdeho if-else-endif a while-endwhile indentuju o jednu uroven neni uplne nejprehlednejsi. ChatGPT tohle umi mnohem lip, akorat tam nic nedisassembluje, ale generuje novy kod, kde ten vyznam zna, a indentaci to AI nekdo zrejme naucil (otazka je zda sikovnymi pravidly, nebo opet pres uceni).

Vývoj / Re:C pre-preprocesor

« kdy: 18. 04. 2023, 15:36:35 »

Ja to nemyslel ze bych to resil pres AI, ale ze konkretne ChatGPT to obcas tiskne moc hezky a vidim v tom nejaky smysl.

To co pises je celkem jasne, ale prave ta pravidla jak to delat uz tak jasna nejsou. Kdyz si vezmu ruzne ukazky praktickych kodu, tak obcas sam nevim jak to udelat "hezky". Treba kde se v loopu skace tam-zpet a je tam treba nejaka dvojita podminka ... tohle nevim jak udelat aby to bylo dostatecne čitelné (ani rucne v editoru nemam jasno, dabel je v tech detailech).

Ona ta indentace asm je takova nouzovka pro zprehledneni, ale je to "zadarmo" - zrovna to bych mohl trivialne implementovat, moje disassemblery oznacuji skoky i terminacni instrukce (jump && !terminace ==> podmineny skok) pro analyzu flow.

Vývoj / Re:C pre-preprocesor

« kdy: 18. 04. 2023, 10:06:23 »

Problem techto nastroju je, ze kdyz chce clovek neco specifickeho, stoji casto vic casu jejich prepracovani, nez udelat vyvoj "skoro od nuly". Myslim tim to, ze nekde najdu vhodny zdroj opkodu a ten pouziju-napsat jednoduchy disasm pro novou architekturu je pak otazka odpoledne. Diky nejakemu odkazu tady jsem objevil, ze Ghidra ma slusnou definici opkodu pro TriCore, ktery ted budu potrebovat udelat.

Mam tu ale dalsi tema a to je indentace assembler kodu (podobne jako IDA umi udelat strom). Hezky to obcas dela ChatGPT, zde je priklad:

Kód: [Vybrat]

        ; Load array address into r0
        LDR r0, =ARRAY
        ; Load array size into r1
        LDR r1, =SIZE
        ; Subtract 1 from array size
        SUBS r1, #1
        ; Loop outer
        outer_loop:
                ; Move outer loop index to r2
                MOV r2, r1
                ; Move outer loop index to r3
                MOV r3, r1
                ; Loop inner
                inner_loop:
                        ; Load ARRAY[r2].x into r4
                        LDRB r4, [r0, r2]
                        ; Load ARRAY[r2].y into r5
                        LDRB r5, [r0, r2, LSL #1]
                        ; Load ARRAY[r3].x into r6
                        LDRB r6, [r0, r3]
                        ; Load ARRAY[r3].y into r7
                        LDRB r7, [r0, r3, LSL #1]
                        ; Compare x values
                        CMP r4, r6
                        ; If ARRAY[r2].x >= ARRAY[r3].x, skip swap
                        IT GE
                        MOVGE r9, r2
                        MOVGE r2, r3
                        MOVGE r3, r9
                        ; Compare y values
                        CMP r5, r7
                        ; If ARRAY[r2].y >= ARRAY[r3].y, skip swap
                        IT GE
                        MOVGE r9, r2
                        MOVGE r2, r3
                        MOVGE r3, r9
                        ; Decrement inner loop index
                        SUBS r2, r2, #1
                        ; Loop inner while inner loop index >= 0
                        BGE inner_loop
                ; Decrement outer loop index
                SUBS r1, r1, #1
                ; Loop outer while outer loop index >= 0
                BGE outer_loop
        ; Return
        BX lr

Mate nejaky napad na pravidla jak tohle delat? Jsou jasne ruzne if-else-endif, pokud jdou po sobe, ale ne vzdy to tak je. Uvital bych odkazy na pripadne dalsi nastroje, ktere tohle nejak umi. ChatGPT jsem se ptal jestli mi napise pravidla ktera pouziva a kdybych veril ze tam je "rozum", tak bych rekl, ze "jsme si vubec neporozumeli" :-). Ani na nekolikaty pokus ji vysvetlit co mne zajima.

Vývoj / Re:C pre-preprocesor

« kdy: 11. 04. 2023, 20:24:12 »

Takze vse vyresim humpolackou metodou, radky tak, ze udelam spravny pocet newline za svym prepsanym kodem, aby to odpovidalo zdrojaku. A necham to at si vsechno resi pravidla Makefile, pro MSVC asi pres pre-compile command.

Prijde mi zajimave jak jsem dostal hromadu odpovedi ... ale ne na moje otazky

.

CPU: Na tvorbe C pre-precompileru bych svoji karieru asi nestavel.

Vývoj / Re:C pre-preprocesor

« kdy: 09. 04. 2023, 21:42:32 »

Dekuji za odpovedi, prestoze tedy neodpovidaji na me otazky, ale budiz. Otazky jsou stale aktualni

.

Duvody proc to chci takhle jsou asi 2, prvni je aby to bylo rychle; ten disassembler je i "analyzujici", a ja jsem liny clovek, takze celkem hrubou silou budu hledat zpetne treba kde se pushuji argumenty na stack, bez toho abych tam delal nejake slozitejsi veci. Takze nejake neustale prochazeni toho bitstringu v nejake fci je neunosne, i moje cesta je celkem pomala, mozna bude nutne "vetsi kalibr" ve forme nejakeho rozeskakavani (prirazeni od promennych jsem v minulosti resil pres varargs, argumenty vzdy v paru int* kamToUlozit a char oznacenibitu, callback neni nutny). Druha vec je prehlednost, kod ktery treba navrhuje RDa pro mne neni jednoduse naprogramovatelny bez chyb, a neni prilis snadno udrzovatelny. Muzu sem dat priklad jak vypada treba risc-v, ktery je celkem slusne navrzeny a neni to obvykle cunecina typu "kdyz jsou v instrukci XYZ nastaveny bity 567 do 101 tak je to vlastne uplne jina instrukce ABC

". I tak je to uz na hrane, kdyz tam clovek pak chce neco pridat, musi premyslet kam presne to dat aby neco nerozbil.

Kód: [Vybrat]

    //0010011 ADDI, SLTI, SLTIU, XORI, ORI, ANDI
    //0010011 SLLI, SRLI, SRAI
    if ( (opcode & 0x7F) == 0x13) {
          switch ((opcode>>12) &7) {
           case 0b000: opname = "addi"; break;
           case 0b010: opname = "slti"; break;
           case 0b011: opname = "sltiu"; break;
           case 0b100: opname = "xori"; break;
           case 0b110: opname = "ori"; break;
           case 0b111: opname = "andi"; break;
           default: opname = NULL; break;
          }
          simmval = SIGNEXT( ((opcode>>20)&0xFFF),12);
          if (opname) {
            if (rel != NULL && ELF32_R_TYPE (rel->r_info) == R_RISCV_LO12_I && (rel->r_addend&0xFFF) == (simmval&0xFFF)) {
                        sprintf (line, "%s %s, %s, %%lo(%s)", opname, riscv_regnames[bits7_11], riscv_regnames[bits15_19], fmt_opt_addend(get_symbol_name (ELF32_R_SYM (rel->r_info)), rel->r_addend));
                        *relparsed = 1;
                      } else {           
	    sprintf (line, "%s %s, %s, %s", opname, riscv_regnames[bits7_11], riscv_regnames[bits15_19], fmt_hexneg(simmval) );
            }
            return 4;
          }
          
          if ( ((opcode>>12) &7) == 0b001 && ((opcode>>25) &0x7F) == 0 )
           opname = "slli";
          if ( ((opcode>>12) &7) == 0b101 && ((opcode>>25) &0x7F) == 0 )
           opname = "srli";
          if ( ((opcode>>12) &7) == 0b101 && ((opcode>>25) &0x7F) == 0b0100000 )
           opname = "srai";


          if (opname) {
	    sprintf (line, "%s %s, %s, 0x%03X", opname, riscv_regnames[bits7_11], riscv_regnames[bits15_19],  ((opcode>>20)&0xFF) );
            return 4;
          }

    }

Prumerne bych odhadnul ze udelam kazdou ctvrtou-patou instrukci nejakou chybu behem pocitani tech bitshiftu/andu/permutaci a uz mne to moc nebavi, ten tool je cesta k vysledku, ne smysl meho zivota.

Nechapu taky co bych ziskal implementaci v C++, krome toho ze bych to nemel na tisicovce (dvou) radek, ale treba v trech stech tridach ? Z toho mi uplne beha mraz po zadech. Ale je mozne, ze jsem celou teorii okolo OOP vlastne prilis nepochopil. _{Kdyz jsem psal ten C lexer, pri cteni vlastnosti modernich C++ jsem jenom ziral a ujistoval se, ze to neni nejaky omyl. Zajimalo by mne, jestli existuje na tehle planete nejaky clovek, ktery skutecne vsemu v C++ rozumi a je schopen rict "co se stane kdyz ..."}

Vývoj / C pre-preprocesor

« kdy: 09. 04. 2023, 01:31:27 »

Pisu nejaky disassembler pro ne uplne bezny RISCovy procesor. Potrebuju nejak rozumne v cecku udelat to, abych mohl porovnavat masky instrukci (vyznamove bity jsou ruzne rozesety) a soucasne jsem mohl extrahovat jednotlive bity do promennych. Tohle se pise hrozne blbe v cistem C, tak jsem zacal psat program, ktery rozepise kazde volani fiktivni fce bitmatch(var,bitmask[,assignments]) tak, aby vratila nonzero kdyz dojde k matchi instrukce a vyextrahovala mi bity do promennych. Takhle zustava kod celkem slusne citelny a je to syntakticky podobne cecku, takze jdou pouzit indentory, syntax highlighting, apod. Zde je priklad:

Kód: [Vybrat]

  if (bitmatch
      (opcode, '01010a100aabab.' /*an opcode */ , rd /*target reg */  =
       b, rs = a))
    {
      printf ("ok");
    }

vystup:

Kód: [Vybrat]

  if (/*.................................................01010a100aabab.*/ ((opcode & 0x7DC0) == 0x2900) && (rd = ((opcode>>1)&0x1)<<0|((opcode>>3)&0x1)<<1,rs = ((opcode>>2)&0x1)<<0|((opcode>>4)&0x3)<<1|((opcode>>9)&0x1)<<3,1))
    {
      printf ("ok");
    }

(neni to jeste dodelane, tohle je fiktivni instrukce, a je pozde a nejsem si jist jestli tam nemam nejakou botu)

Z jineho projektu mam napsany C lexikalni analyzator (tokenizer), ktery jsem na to pouzil, jeho funkce je primitivni, najde dalsi token a naplni strukturu s informacemi o tokenu. Udelal jsem tedy primitivni preprocesor, ktery z meho pseudo-c generuje cecko (lokalizuje identifikator bitmatch a slepe prepise do C kodu):

Kód: [Vybrat]

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "ctok.h"

void
synterr (struct ctok *tok, const char *whatiswrong)
{
  printf ("Syntax error: %s\n", whatiswrong);
  exit (1);
}

int
main (int argc, char **argv)
{
  struct ctok tok;
  int pos, lastwpos;
  int i, j, k;
  int bs, be, bp;
  char varname[0x100], valname[0x100], bitmask[64];
  unsigned long long bmmask, bmval;


  if (argc != 3)
    {
      printf ("Usage: %s [infile.d.c] [outfile.c]\n", argv[0]); // xxx outfile se ted nepouziva
      exit (1);
    }

  if (ctok_readfile (argv[1]) <= 0)
    {
      perror (argv[1]);
      exit (1);
    }

  fprintf (stdout, "/*Automatically generated by %s, DO NOT EDIT! */\n\n",
           argv[0]);

  lastwpos = pos = 0;
  while (ctok_gettoken (pos, &tok, CTOK_FLAG_IGNORECOMMENTS) > CTOK_EOF)
    {
      // Search for identifier "bitmatch"
      if (tok.toktype == CTOK_IDENT && tok.len == 8
          && !memcmp (tok.data, "bitmatch", tok.len))
        {
          if (lastwpos < pos)
            {
              fwrite (ctok_getdata (lastwpos), pos - lastwpos, 1, stdout);
            }

          if (ctok_gettoken
              (ctok_nexttokpos (&tok), &tok,
               CTOK_FLAG_IGNORECOMMENTS) != CTOK_SYMBOL && tok.info != '(')
            synterr (&tok, "Expected (");

          if (ctok_gettoken
              (ctok_nexttokpos (&tok), &tok,
               CTOK_FLAG_IGNORECOMMENTS) != CTOK_IDENT)
            synterr (&tok, "Expected variable identifier");

          memcpy (varname, tok.data, tok.len);
          varname[tok.len] = 0;

          if (ctok_gettoken
              (ctok_nexttokpos (&tok), &tok,
               CTOK_FLAG_IGNORECOMMENTS) != CTOK_SYMBOL || tok.info != ',')
            synterr (&tok, "Expected \',\' after variable identifier");


          if (ctok_gettoken
              (ctok_nexttokpos (&tok), &tok,
               CTOK_FLAG_IGNORECOMMENTS) != CTOK_CHARLIT)
            synterr (&tok, "Expected bitmask");


          memcpy (bitmask + 64 - tok.len, tok.data, tok.len);

          // ignore spaces in bits, these are just for better readibility
          for (i = 0, j = 0; i < tok.len; i++)
            if (tok.data[i] != ' ')
              bitmask[j++] = tok.data[i];

          memmove (bitmask + 64 - j, bitmask, j);
          memset (bitmask, '.', 64 - j);

          bmval = bmmask = 0;
          for (i = 0; i < 64; i++)
            if (bitmask[63 - i] == '0' || bitmask[63 - i] == '1')
              {
                bmmask |= 1ULL << i;
                if (bitmask[63 - i] == '1')
                  bmval |= 1ULL << i;
              }

          printf ("/*%64.64s*/ ((%s & 0x%llX%s) == 0x%llX%s) && (", bitmask,
                  varname, bmmask, (bmmask >> 32) != 0 ? "ULL" : "", bmval,
                  (bmval >> 32) != 0 ? "ULL" : "");

          while (1)
            {
              if (ctok_gettoken
                  (ctok_nexttokpos (&tok), &tok,
                   CTOK_FLAG_IGNORECOMMENTS) != CTOK_SYMBOL
                  || (tok.info != ')' && tok.info != ','))
                synterr (&tok, "Expected , or )");

              if (tok.info == ')')
                break;

              if (ctok_gettoken
                  (ctok_nexttokpos (&tok), &tok,
                   CTOK_FLAG_IGNORECOMMENTS) != CTOK_IDENT)
                synterr (&tok, "Expected variable identifier");

              memcpy (valname, tok.data, tok.len);
              valname[tok.len] = 0;


              if (ctok_gettoken
                  (ctok_nexttokpos (&tok), &tok,
                   CTOK_FLAG_IGNORECOMMENTS) != CTOK_SYMBOL
                  || tok.info != '=')
                synterr (&tok, "Expected = for bits assignment");

              if (ctok_gettoken
                  (ctok_nexttokpos (&tok), &tok,
                   CTOK_FLAG_IGNORECOMMENTS) != CTOK_IDENT || tok.len != 1)
                synterr (&tok, "Expected bit letter/identifier");

              printf ("%s = ", valname);

              // calculate bit extraction equations
              for (bp = 0, i = 0; i < 64; i++)
                if (bitmask[64 - 1 - i] == tok.data[0])
                  {
                    bs = i;
                    while (i < 64 && bitmask[64 - 1 - i] == tok.data[0])
                      i++;
                    be = i;
                    if (bp != 0)
                      printf ("|");
                    printf ("((%s>>%d)&0x%X)<<%d", varname, bs,
                            (1 << (be - bs)) - 1, bp);
                    bp += be - bs;
                  }
              if (bp == 0)
                {
                  printf ("No matching bits for variable %s\n", valname);
                  exit (1);
                }

              printf (",");

            }                   // while new stuff for bit assignment

          printf ("1)");

          lastwpos = ctok_nexttokpos (&tok);
        }                       // if "bitmatch" identifier token


      pos = ctok_nexttokpos (&tok);

    }

  if (tok.toktype != CTOK_EOF)
    synterr (&tok, "C parser error");

  if (lastwpos < pos)
    {
      fwrite (ctok_getdata (lastwpos), pos - lastwpos, 1, stdout);
    }


  return 0;
}

Cilove prekladace jsou gcc, llvm, msvc.

Ma to 2 problemy:

- idealne bych potreboval nejak vystup poslat do prekladace bez generovani mezisouboru. Videl jsem nejake snahy o vlastni preprocesor ( https://stackoverflow.com/questions/3545875/custom-gcc-preprocessor ), ale takhle to nechci, navic msvc (Windows) bude problem. Idealni by byl nejaky parametr typu '-custom-preprocessor-before-cpp1=...'. Nenasel jsem. Nebo to tam dostat pres pipe. Nenasel jsem jak.

- potrebuju zachovat cisla radek (pocitejme s tim, ze nahrazovane "volani" bitmatch budou i viceradkova, s komentari,atd.) , aby kdyz se seknu nekde v kodu slo hledat chyby (nutne aby to chodilo alespon v gcc/llvm, msvc by bylo fajn, predpokladam ze #line by to nejak mel resit, ale nejak se mi zatim nedari. Jak na to?

Mimo tyto dotazy by mne jeste zajimalo, jestli nejake moderni jazyky poskytuji knihovny, ktere tohle umoznuji napsat s kratsim kodem. C tokenizer vyuziva jen libc a ma pocty radek: 740 ctok.c / 177 ctok.h; jsem takova kozerva, treba mi nekdo ukazete ze s "modernim programovanim" to jde udelat jednoduseji.

Hardware / Re:Získání dat z diskety ve formátu IBM HDR1

« kdy: 28. 03. 2023, 13:05:26 »

Emulator nemam, ale to vubec nevadi. Diskety uz ctu.

Jedna se o diskety k tomuhle http://www.ebastlirna.cz/modules.php?name=Forums&file=viewtopic&t=77106&postdays=0&postorder=asc&highlight=c2715&start=0 - je to nejspis klon IBM 5280, tedy to je otazka do jake miry to je identicke.

Resim ted otazku ohledne jejich "assembleru" BAL. Mam napsany disassembler, ktery zchroupe ROMku z te C2715 a celkem to i dava smysl, ovsem u programu z disket mi to nesedi a nevim proc. Trosku mi to cele pripomina, ze z BALu leze nejaky pseudokod, mozna nasledne interpretovane opkody pro nejaky IBM Mainframe.

Nekdo se tu kdysi jak se matne pamatuji zminoval, ze mu lezi doma ladem nerozchozeny nejaky IBM mainframe, ozve se mi? Pripadne jestli s tim nekdo mate zkusenost a na prvni pohled vidite zda to je IBM 8250 kompatibilni?

Kód: [Vybrat]

114E: BBK 11 40          # pointer na tisteny retezec
1151: BBW 26 11
1154: VIW
1155: NUS
1156: PS0
1157: BWW 00 00 00
115B: WUW
115C: P1K
115D: BBK 10 db
1160: BBW 26 11
1163: VIW
1164: P0S
1165: SVE
1166: VIW
1167: NOP
1168: NOP
1169: NOP
116A: IN2 75
116D: B1L 08
116F: BBK ff ff
1172: B1S 01
1174: PSM
1175: PM1
1176: VS1

Hardware / Re:IBM diskety "HDR1" - format, jak extrahovat

« kdy: 23. 03. 2023, 20:13:28 »

Diky

..

zda se, ze vse je popsane v ISO7665

Information processing — File structure and labelling
of flexible disk cartridges for information interchange
Traitement de /'information — Structure des fichiers et dtiquetage des cartouches a disquette pour I'echange d'information
First edition — 1983-12-15

HDR1 tam ma 128bytu, je tam i ERMAP, atd...

A navic je to popsane v systemovem manualu k Consulu 2715... to jsem hledal fakt blbe, ze jsem nenasel.

Hardware / Získání dat z diskety ve formátu IBM HDR1

« kdy: 23. 03. 2023, 17:19:54 »

Abych nevymyslel znovu kolo, radsi se zeptam mistnich odborniku .. tusite jak extrahovat diskety IBM formatu s "HDR1"? Vypada to celkem podobne k https://www.ibm.com/docs/en/zos/2.1.0?topic=format-standard-data-set-label-1-hdr1eov1eof1

konkretne mi jde o http://www.bitsavers.org/bits/IBM/5280/SS/ ; zde davam dump prevedeny z EBCDIC na citelne ASCII (vlevo HEX je original):

Kód: [Vybrat]

EBCDIC dump SYSCON7.IMD:
00000000:  49 4D 44 20 31 2E 31 38  3A 20 20 36 2F 30 38 2F | .(..............
00000010:  32 30 31 37 20 31 35 3A  30 38 3A 33 36 0D 0A 1A | ................  tohle je ASCII hlavicka toho image
00000020:  00 00 00 1A 00 01 02 03  04 05 06 07 08 09 0A 0B | ................
00000030:  0C 0D 0E 0F 10 11 12 13  14 15 16 17 18 19 1A 01 | ................
00000040:  C9 D7 D3 F0 F8 40 40 40  40 40 40 40 40 40 40 40 | IPL08
00000050:  40 40 40 40 40 40 40 40  40 40 40 40 40 40 40 40 |
00000060:  40 40 40 40 40 40 40 40  40 40 40 40 40 40 40 40 |
00000070:  40 40 40 40 40 40 40 40  40 40 40 40 40 40 40 40 |
00000080:  40 40 40 40 40 40 40 40  40 40 40 40 40 40 40 40 |
00000090:  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00 | ................
000000A0:  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00 | ................
000000B0:  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00 | ................
000000C0:  01 40 40 40 40 40 40 40  40 40 40 40 40 40 40 40 | .
000000D0:  40 40 40 40 40 40 40 40  40 40 40 40 40 40 40 40 |
000000E0:  40 40 40 40 40 40 40 40  40 40 40 40 40 40 40 40 |
000000F0:  40 40 40 40 40 40 40 40  40 40 40 40 40 40 40 40 |
00000100:  40 40 40 40 40 40 40 40  40 40 40 40 40 40 40 40 |
00000110:  40 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00 |  ...............
00000120:  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00 | ................
00000130:  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00 | ................
00000140:  00 01 40 40 40 40 40 40  40 40 40 40 40 40 40 40 | ..
00000150:  40 40 40 40 40 40 40 40  40 40 40 40 40 40 40 40 |
00000160:  40 40 40 40 40 40 40 40  40 40 40 40 40 40 40 40 |
00000170:  40 40 40 40 40 40 40 40  40 40 40 40 40 40 40 40 |
00000180:  40 40 40 40 40 40 40 40  40 40 40 40 40 40 40 40 |
00000190:  40 40 00 00 00 00 00 00  00 00 00 00 00 00 00 00 |   ..............
000001A0:  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00 | ................
000001B0:  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00 | ................
000001C0:  00 00 01 40 40 40 40 40  40 40 40 40 40 40 40 40 | ...
000001D0:  40 40 40 40 40 40 40 40  40 40 40 40 40 40 40 40 |
000001E0:  40 40 40 40 40 40 40 40  40 40 40 40 40 40 40 40 |
000001F0:  40 40 40 40 40 40 40 40  40 40 40 40 40 40 40 40 |
00000200:  40 40 40 40 40 40 40 40  40 40 40 40 40 40 40 40 |
00000210:  40 40 40 00 00 00 00 00  00 00 00 00 00 00 00 00 |    .............
00000220:  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00 | ................
00000230:  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00 | ................
00000240:  00 00 00 01 C5 D9 D4 C1  D7 40 40 40 40 40 40 40 | ....ERMAP
00000250:  40 40 40 40 40 40 40 40  40 40 40 40 40 40 40 40 |
00000260:  40 40 40 40 40 40 40 40  40 40 40 40 40 40 40 40 |
00000270:  40 40 40 40 40 40 40 40  40 40 40 40 40 40 40 40 |
00000280:  40 40 40 40 40 40 40 40  40 40 40 40 40 40 40 40 |
00000290:  40 40 40 40 00 00 00 00  00 00 00 00 00 00 00 00 |     ............
000002A0:  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00 | ................
000002B0:  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00 | ................
000002C0:  00 00 00 00 01 40 40 40  40 40 40 40 40 40 40 40 | .....
000002D0:  40 40 40 40 40 40 40 40  40 40 40 40 40 40 40 40 |
000002E0:  40 40 40 40 40 40 40 40  40 40 40 40 40 40 40 40 |
000002F0:  40 40 40 40 40 40 40 40  40 40 40 40 40 40 40 40 |
00000300:  40 40 40 40 40 40 40 40  40 40 40 40 40 40 40 40 |
00000310:  40 40 40 40 40 00 00 00  00 00 00 00 00 00 00 00 |      ...........
00000320:  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00 | ................
00000330:  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00 | ................
00000340:  00 00 00 00 00 01 E5 D6  D3 F1 F5 F7 F0 F8 E2 C3 | ......VOL15708SC
00000350:  40 40 40 40 40 40 40 40  40 40 40 40 40 40 C9 C2 |               IB
00000360:  D4 F5 F2 F8 F0 40 40 40  40 40 40 F2 F9 F2 F4 E2 | M5280      2924S
00000370:  C3 F1 D9 F0 F7 F0 E5 F0  F1 40 40 40 40 40 40 40 | C1R070V01
00000380:  40 40 40 40 40 40 40 40  40 40 40 40 40 40 40 40 |
00000390:  40 F1 F0 F1 40 E6 00 00  00 00 00 00 00 00 00 00 |  101 W..........
000003A0:  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00 | ................
000003B0:  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00 | ................
000003C0:  00 00 00 00 00 00 01 C8  C4 D9 F1 40 E2 E8 E2 C9 | .......HDR1 SYSI
000003D0:  D7 D3 40 40 40 40 40 40  40 40 40 40 40 40 40 F2 | PL             2
000003E0:  F5 F6 D9 F0 F1 F0 F0 F1  F1 F0 F4 F0 F1 F0 40 40 | 56R01001104010
000003F0:  40 40 C9 40 40 40 F8 F3  F0 F4 F1 F9 40 F2 F5 F6 |   I   830419 256
00000400:  40 40 40 40 40 40 40 40  40 40 40 40 40 40 40 40 |
00000410:  C4 F0 F4 F0 F1 F1 40 40  40 40 40 40 40 40 40 40 | D04011
00000420:  40 40 40 40 40 40 C9 C2  D4 F5 F2 F8 F0 40 40 40 |       IBM5280
00000430:  40 40 40 40 40 40 40 40  40 40 40 40 40 40 40 40 |
00000440:  40 40 40 40 40 40 40 01  C8 C4 D9 F1 40 E2 E8 E2 |        .HDR1 SYS
00000450:  C4 C9 D7 D3 40 40 40 40  40 40 40 40 40 40 40 40 | DIPL
00000460:  F2 F5 F6 D9 F0 F4 F0 F1  F1 F1 F0 F5 F0 F1 F4 40 | 256R04011105014
00000470:  40 40 40 C9 40 40 40 F8  F3 F0 F4 F1 F9 40 F2 F5 |    I   830419 25
00000480:  F6 40 40 40 40 40 40 40  40 40 40 40 40 40 40 40 | 6
00000490:  40 C4 F0 F5 F0 F1 F5 40  40 40 40 40 40 40 40 40 |  D05015
000004A0:  40 40 40 40 40 40 40 C9  C2 D4 F5 F2 F8 F0 40 40 |        IBM5280
000004B0:  40 40 40 40 40 40 40 40  40 40 40 40 40 40 40 40 |
000004C0:  40 40 40 40 40 40 40 40  01 C8 C4 D9 F1 40 E2 E8 |         .HDR1 SY
000004D0:  E2 C4 D7 D9 E3 F1 40 40  40 40 40 40 40 40 40 40 | SDPRT1
000004E0:  40 F2 F5 F6 D9 F0 F5 F0  F1 F5 F1 F0 F6 F0 F1 F1 |  256R05015106011
000004F0:  40 40 40 40 C9 40 40 40  F8 F3 F0 F4 F1 F9 40 F2 |     I   830419 2
00000500:  F5 F6 40 40 40 40 40 40  40 40 40 40 40 40 40 40 | 56
00000510:  40 40 C4 F0 F6 F0 F1 F2  40 40 40 40 40 40 40 40 |   D06012
00000520:  40 40 40 40 40 40 40 40  C9 C2 D4 F5 F2 F8 F0 40 |         IBM5280
00000530:  40 40 40 40 40 40 40 40  40 40 40 40 40 40 40 40 |
00000540:  40 40 40 40 40 40 40 40  40 01 C8 C4 D9 F1 40 E2 |          .HDR1 S
00000550:  E8 E2 E3 C2 D3 E2 40 40  40 40 40 40 40 40 40 40 | YSTBLS
00000560:  40 40 F2 F5 F6 D9 F0 F6  F0 F1 F2 F1 F2 F1 F0 F1 |   256R0601212101
00000570:  F4 40 40 40 40 C9 40 40  40 F8 F3 F0 F4 F1 F9 40 | 4    I   830419
00000580:  F2 F5 F6 40 40 40 40 40  40 40 40 40 40 40 40 40 | 256
00000590:  40 40 40 C4 F2 F1 F0 F1  F5 40 40 40 40 40 40 40 |    D21015
000005A0:  40 40 40 40 40 40 40 40  40 C9 C2 D4 F5 F2 F8 F0 |          IBM5280
000005B0:  40 40 40 40 40 40 40 40  40 40 40 40 40 40 40 40 |
000005C0:  40 40 40 40 40 40 40 40  40 40 01 C8 C4 D9 F1 40 |           .HDR1
000005D0:  E2 E8 E2 C4 D7 D9 E3 F2  40 40 40 40 40 40 40 40 | SYSDPRT2
000005E0:  40 40 40 F2 F5 F6 D9 F2  F1 F0 F1 F5 F1 F2 F3 F0 |    256R210151230
000005F0:  F0 F8 40 40 40 40 C9 40  40 40 F8 F3 F0 F4 F1 F9 | 08    I   830419
00000600:  40 F2 F5 F6 40 40 40 40  40 40 40 40 40 40 40 40 |  256
00000610:  40 40 40 40 C4 F2 F3 F0  F0 F9 40 40 40 40 40 40 |     D23009
00000620:  40 40 40 40 40 40 40 40  40 40 C9 C2 D4 F5 F2 F8 |           IBM528
00000630:  F0 40 40 40 40 40 40 40  40 40 40 40 40 40 40 40 | 0
00000640:  40 40 40 40 40 40 40 40  40 40 40 01 C8 C4 D9 F1 |            .HDR1
00000650:  40 E2 E8 E2 C3 D3 D6 E2  C5 40 40 40 40 40 40 40 |  SYSCLOSE
00000660:  40 40 40 40 F2 F5 F6 D9  F2 F3 F0 F0 F9 F1 F2 F4 |     256R23009124
00000670:  F0 F1 F5 40 40 40 40 C9  40 40 40 F8 F3 F0 F4 F1 | 015    I   83041
00000680:  F9 40 F2 F5 F6 40 40 40  40 40 40 40 40 40 40 40 | 9 256
00000690:  40 40 40 40 40 C4 F2 F5  F0 F0 F1 40 40 40 40 40 |      D25001
000006A0:  40 40 40 40 40 40 40 40  40 40 40 C9 C2 D4 F5 F2 |            IBM52
000006B0:  F8 F0 40 40 40 40 40 40  40 40 40 40 40 40 40 40 | 80
000006C0:  40 40 40 40 40 40 40 40  40 40 40 40 01 C8 C4 D9 |             .HDR
000006D0:  F1 40 E2 E8 E2 C3 D6 D5  40 40 40 40 40 40 40 40 | 1 SYSCON
000006E0:  40 40 40 40 40 F2 F5 F6  D9 F2 F5 F0 F0 F1 F1 F2 |      256R2500112
000006F0:  F9 F0 F0 F3 40 40 40 40  C9 40 40 40 F8 F3 F0 F4 | 9003    I   8304
00000700:  F1 F9 40 F2 F5 F6 40 40  40 40 40 40 40 40 40 40 | 19 256
00000710:  40 40 40 40 40 40 C4 F2  F9 F0 F0 F4 40 40 40 40 |       D29004
...

Diky za nakopnuti ... cilem je z diskety vytahnout jednotlive soubory (zaznamy).

Pripadne jestli nekdo tusite kde jsou nejake informace k IBM 5280 (jine nez na bitsavers, tam jsou akorat ty diskety a nejake manualy).

Hardware / Re:Sháním informace o ZVT SPU 800 (TP8)

« kdy: 13. 03. 2023, 17:34:49 »

Dovoluji si ozivit toto starsi tema - nejake informace k pocitaci se podarilo sehnat, a co vic, zapujceny mam i pocitac samotny (zrejme nefunkcni, nedovolim si ho dat pod napeti

). Aktualne tedy shanim jakykoliv SW k tomuto pocitaci. Pokud nekoho zajima jak zhruba to realne vypada a vnitrne funguje, zde je dalsi video: https://www.youtube.com/watch?v=qxyII20Vylo

Bazar / Re:Sháním malý rack za půl darma

« kdy: 03. 03. 2023, 11:57:01 »

my 2 cents: dbejte na pozarni a elektrickou bezpecnost. tzn. material, ktery nepodpali dum kdyz vyhori napajec zdroje, ukapne a kus nejakeho kovu, nebo to tam dokonce bude horet. Kovove casti je potreba uzemnit (jinak nez pres PE vodic pripojovaci vidlice switche).

Sam mam na pude neco na tento zpusob: https://www.esvit.cz/skrin-s3d-400x300x200-mp-nsys3d4320p-schneider

Vývoj / Re:RISC-V assembler

« kdy: 28. 02. 2023, 18:28:55 »

Eh ... tolik reci o RISC-V a jen jedna odpoved (za ni presto dekuji).

aktualne nevim uz asi jen 5), zbytek jsem si prubezne zjistil, tak kdyby to resil nekdo dalsi, kdo opravdu realne R-V pouziva a ne jen o nem mluvi

...

Prekladacem si nejsem jist zda vygeneruje vzdy spravny kod, ale zda se funguje " riscv64-linux-gnu-gcc -c -march=rv32imc -mabi=ilp32 test.c -fno-plt -fno-pie -fno-pic", chci-li kod pro 32bit mikrokontroller (rv23imc apod.)

No a nakonec %hi(X) a %lo(X) resi ty offsety pro lui/auipc a jejich protejsky lw/jalr v GNU as.

Stran: 1 [2] 3 4 ... 33