fork download

copy

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
 
 
#define true 1
#define false 0
typedef unsigned char Char;
 
 
Char p[2000];  /* This is memory */
int programLength;
int littleEndian = true;
int num_words;
 
int* eax;
int* ecx;
int* edx;
int* ebx;
int* esi;
int* edi;
int* esp;
int* ebp;
 
int pc;
int codes; /* status, condition codes[3]; control and status flags */
 
void setup()
{
        /* get the file from arc */
    eax = malloc(sizeof(int*));
    ecx = malloc(sizeof(int*));
    edx = malloc(sizeof(int*));
    ebx = malloc(sizeof(int*));
    esi = malloc(sizeof(int*));
    edi = malloc(sizeof(int*));
    esp = malloc(sizeof(int*));
    ebp = malloc(sizeof(int*));
    *eax = *ecx = *edx = *ebx = *esi = *edi = *esp = *ebp = pc = 0;
    printf("setup done");
}
Char aToH(Char x)
{
  if(x > '/' && x < ':')
   x=(Char) (x-48);
  else
  {
    if(x>'`' && x<'g')
      x=(Char) (x-87);
  }
  return x;
}
 
int FASCII(Char z[])
{
  int b=0;
  programLength=0;
  if(*z=='\0')
  {
    printf("NO CHARS\n");
    return 1;
  }
  else
  {
    for(int a=0; z[a]!='\0'; a++)
    {
      Char s=aToH(z[a]);
      Char t=aToH(z[a+1]);
      p[b]=(Char) (s << 4|t);
      printf("%x ", p[b] & 0xff);
      a++;
      b++;
    }
    programLength = b;
  }
  printf("\n");
  return 0;
}
 
/* Zero flag operations */
void setZF()
{
  codes = codes | 64;  /* sets the 01000000 flag */
  printf("	ZF flag set");
}
 
void setFlags(int a, int b, int result)
    {
        clearFlags();
        if (result == 0)
            setZF();
        if (result < 0)
            setSF();
        if (((a & 128) == 128 &&  (b & 128) == 128 &  (result & 128) == 0) ||
            ((a & 128) == 0   &&  (b & 128) == 0   &  (result & 128) == 128))
            setOF();
    }
 
 
void clearZF()
{/* clears 10111111 flag */
    // if set, clear
    // if clear, clear
  codes= codes & 64;
}
 
int getZF()
{
  if((codes & 63) == 64)
    return 1;
  return 0;
}
 
 
 
/* Sign Flag operations */
void setSF()
{
  codes = codes | 32;  /* sets the 00100000 flag */
  printf("	SF flag set");
}
 
void clearSF()
{
  codes = codes & 32;
}
 
void clearOF()
{
  codes = codes & 16;
}
 
void clearFlags()
{
  clearSF();
  clearZF();
  clearOF();
}
 
int getSF()
{
  if((codes & 32) == 32)
    return 1;
  return 0;
}
 
/* Overflow flag operations */
void setOF()
{
  codes = codes | 16;  /* sets the 00010000 flag */
  printf("	OF flag set");
}
 
 
 
int getOF()
{
  if((codes & 16) == 16 )
    return 1;
  return 0;
}
 
void clearStatus()
{
  codes = codes & (255 - 15);  /* 11110000 - clears last four bits */
}
 
/* Status code operations (last four bits) */
void setAOK()
{
  clearStatus();
  codes = codes | 1;  /* sets 00000001 */
  printf("	set status = AOK");
}
 
void setHLT()
{
  clearStatus();
  codes = codes | 2;  /* sets 00000010 */
  printf("	set status = HLT");
}
 
void setADR()
{
  clearStatus();
  codes = codes | 3;  /* sets 00000011 */
  printf("	set status = ADR");
}
 
void setINS()
{
  clearStatus();
  codes = codes | 4;  /* sets 00000010 */
  printf("	set status = INS");
}
 
int getStatus()
{
  return codes & 0xf0;
}
 
/*
 * Prints out the values of the registers */
void printRegisters()
{
  printf("\teax: %x, ", *eax);
  printf("ecx: %x, ", *ecx);
  printf("edx: %x, ", *edx);
  printf("ebx: %x, ", *ebx);
  printf("esi: %x, ", *esi);
  printf("edi: %x, ", *edi);
  printf("esp: %x, ", *esp);
  printf("ebp: %x, ", *ebp);
  printf("PC: %x, ", pc);
}
 
/* Generates an error then exits the program */
void error(Char words[], int pc)
{
  for(int a=0; words[a] != '\0'; a++)
    printf("%c", words[a]);
  exit(0);
}
 
/* Assembly instructions */
/**
 * halt 00
 */
void halt()
{
  printf("halt");
  setHLT();
  pc+=1;
  printRegisters();
  exit(0);
}
 
 
/**
 * nop 10
 */
void nop()
{
  printf("nop");
  pc+=1;
}
 
 
/**
 ** Gets an integer value from four chars ( based on big * endian or little
 * endian encoding)
 *
 */
int getVal(Char a, Char b, Char c, Char d)
{
  int val;
  if(littleEndian)
  {
    val=a;
    val=val | b << 8;
    val=val | c << 16;
    val=val | d << 32;
  }
  else
  {
    val=a;
    val=val | b << 4;
    val=val | c << 8;
    val=val | d << 16;
  }
  return val;
}
 
/*
Computes the register from the first part of the Char
passed in. Returns a pointer to the register given
character code as input.
0 eax; 1 ecx; 2 edx; 3 ebx
4 esp; 5ebp; 7 edi
F No register
 */
int* r1(Char a)
{
  switch(a & 0xf0)
  {
    case 0x00:
      return eax;
    case 0x10:
      return ecx;
    case 0x20:
      return edx;
    case 0x30:
      return ebx;
    case 0x40:
      return esp;
    case 0x50:
      return ebp;
    case 0x60:
      return esi;
    case 0x70:
      return edi;
    default:
      printf("Error determining register value. pc=%x", pc);
  }
  return eax; /* shouldn't be hit */
}   
 
 
/*
Computes the register from the second part of the Char
passed in. Returns a pointer to the register given
character code as input.
0 eax; 1 ecx; 2 edx; 3 ebx
4 esp; 5 ebp; 6 esi; 7 edi
F No register
 */ 
int* r2(Char a)
{
  switch(a & 0x0f)
  {
    case 0x00:
      return eax;
    case 0x01:
      return ecx;
    case 0x02:
      return edx;
    case 0x03:
      return ebx;
    case 0x04:
      return esp;
    case 0x05:
      return ebp;
    case 0x06:
      return esi;
    case 0x07:
      return edi;
    default:
      printf("Error determining register value. pc=%x", pc);
  }
  return eax; /* shouldn't be hit */
}   
 
 
/**
 * rrmov1 rA, rB 20 rArB
 */
void rrmov1(Char reg)
{
  int* src = r1(reg);
  int* dst = r2(reg);
  *dst = *src;
  printf("rrmov1 %s, %s: (%x)", src, dst, *dst);
  pc+=2;
}
 
/**
 * cmov1e rA, rB 21 rArB
 */
void cmov1e(Char reg)
{
  int* src = r1(reg);
  int* dst = r2(reg);
  if(getZF() ==1 || getSF() != getOF())
  {
    *dst = *src;
    printf("cmov1e %s, %s: (%x moved)", src, dst, *dst);
  }
  else
        printf("cmov1e %s, %s: (%x not moved)", src, dst, *dst);
  pc+=2;
}
 
/**
 * cmov1 rA, rB 22 rArB
 */
void cmov1(Char reg)
{
  int* src = r1(reg);
  int* dst = r2(reg);
  if(getSF() != getOF())
  {
    *dst = *src;
    printf("cmov1 %s, %s: (%x moved)", src, dst, *dst);
  }
  else
        printf("cmov1 %s, %s: (%x not moved)", src, dst, *dst);
  pc+=2;
}
 
/**
 * cmove rA, rB 23 rArB
 */
void cmove(Char reg)
{
  int* src = r1(reg);
  int* dst = r2(reg);
  if(getZF() ==1)
  {
    *dst = *src;
    printf("cmove %s, %s: (%x moved)", src, dst, *dst);
  }
  else
        printf("cmove %s, %s: (%x not moved)", src, dst, *dst);
  pc+=2;
}
 
/**
 * cmovne rA, rB 24 rArB
 */
void cmovne(Char reg)
{
  int* src = r1(reg);
  int* dst = r2(reg);
  if(getZF() == 0)
  {
    *dst = *src;
    printf("cmovne %s, %s: (%x moved)", src, dst, *dst);
  }
  else
        printf("cmovne %s, %s: (%x not moved)", src, dst, *dst);
  pc+=2;
}
 
/**
 * cmovge rA, rB 21 5ArB
 */
void cmovge(Char reg)
{
  int* src = r1(reg);
  int* dst = r2(reg);
  if(getSF() == getZF())
  {
    dst = src;
    printf("cmovge %s, %s: (%x moved)", src, dst, *dst);
  }
  else
        printf("cmovge %s, %s: (%x not moved)", src, dst, *dst);
  pc+=2;
}
 
/**
 * cmovg rA, rB 26 rArB
 */
void cmovg(Char reg)
{
  int* src = r1(reg);
  int* dst = r2(reg);
  if(getSF() ==0 || getZF() == 0)
  {
    dst = src;
    printf("cmovg %s, %s: (%x moved)", src, dst, *dst);
  }
  else
        printf("cmovg %s, %s: (%x not moved)", src, dst, *dst);
  pc+=2;
}
 
/**
 * irmov1 V, rb 30 FrB Va Vb Vc Vd
 */
void irmov1(int val, Char reg)
{
  int* rB = r2(reg); 
  *rB = val;
  printf("irmov1 %s, %x", rB, *rB & 0xffff);
  pc+=6;
}
 
/**
 * rmmov1 rA, D(rB) 40 rArB Da Db Dc Dd
 */
void rmmov1(Char reg, int offset)
{
  int* rA = r1(reg);
  int* rB = r2(reg);
  loadVal(*rA, *rB + offset);
  printf("rmmov1 %s, %x(%x)", rA, offset & 0xffff, *rB & 0xffff);
  pc+=6;
}
 
/**
 * mrmov1 D(rB), rA 50 rArB Da Db Dc Dd
 */
void mrmov1(Char reg, int offset)
{
  int* rA = r1(reg);
  int* rB = r2(reg);
  *rA = p[*rB + offset];
  printf("mrmov1 %x(%s), %s: (%x)", offset & 0xffff, rB, rA, *rA);
  pc+=6;
}
 
/**
 * add1 rA, rB 60 rArB
 */
void add1(Char reg)
{
  int* src = r1(reg);
  int* dst = r2(reg);
  int* tmp = *dst;
  *dst = *dst + *src;
  printf("add1 %s, %s: (%x)", dst, src, *dst);
  setFlags(*tmp, *src, *dst);
  pc+=2;
}
 
/**
 * sub1 rA, rB 61 rArB
 */
void sub1(Char reg)
{
  int* src = r1(reg);
  int* dst = r2(reg);
  int* tmp = *dst;
  *dst = *dst - *src;
  printf("sub1 %s, %s: (%x)", dst, src, *dst);
  pc+=2;
}
 
/**
 * and1 rA, rB 62 rArB
 */
void and1(Char reg)
{
  int  *src = r1(reg);
  int  *dst = r2(reg);
  int  *tmp = dst;
  *dst = *dst & *src;
  printf("and1 %s, %s: (%x)", dst, src, *dst);
  setFlags(*tmp, *src, *dst);
  pc+=2;
}
 
/**
 * xor1 rA, rB 63 rArB
 */
void xor1(Char reg)
{
  int  *src = r1(reg);
  int  *dst = r2(reg);
  int  *tmp = dst;
  *dst = *dst ^ *src;
  printf("xor1 %s, %s: (%x)", dst, src, *dst);
  setFlags(*tmp, *src, *dst);
  pc+=2;
}
 
/**
 * jmp Dest 70 Da Db Dc Dd
 */
void jmp(int dest)
{
  printf("jmp %x", dest);
  pc=dest;
  printf(" (pc=%x)", dest);
  pc+=5;
}
 
/**
 * j1e Dest 71 Da Db Dc Dd
 */
void j1e(int dest)
{
  printf("j1e %x", dest);
  if(getZF()==1 || getSF()!=getOF())
  {
    pc=dest;
    printf(" (pc=%x)", dest);
  }
  else
  {
    printf(" (no)");
    pc+=5;
  }
}
 
/**
 * j1 Dest 72 Da Db Dc Dd
 */
void j1(int dest)
{
  printf("j1 %x", dest);
  if(getZF()!=getOF())
  {
    pc=dest;
    printf(" (pc=%x)", dest);
  }
  else
  {
    printf(" (no)");
    pc+=5;
  }
}
 
/**
 * je Dest 73 Da Db Dc Dd
 */
void je(int dest)
{
  printf("je %x", dest);
  if(getZF()==1)
  {
    pc=dest;
    printf(" (tak)");
  }
  else
  {
    printf(" (no)");
    pc+=5;
  }
}
 
/**
 * jne Dest 74 Da Db Dc Dd
 */
void jne(int dest)
{
  printf("jne %x", dest);
  if(getZF()==0)
  {
    pc=dest;
    printf(" (pc=%x)", pc & 0xff);
  }
  else
  {
    printf(" (not taken)");
    pc+=5;
  }
}
 
/**
 * jge Dest 75 Da Db Dc Dd
 */
void jge(int dest)
{
  printf("jge %x", dest);
  if(getZF()==getSF())
  {
    pc=dest;
    printf(" (pc=%x)", dest);
  }
  else
  {
    printf(" (no)");
    pc+=5;
  }
}
 
/**
 * jg Dest 76 Da Db Dc Dd
 */
void jg(int dest)
{
  printf("jg %x", dest);
  if(getZF()==0 && getSF()==0)
  {
    pc=dest;
    printf(" (pc=%x)", dest);
  }
  else
  {
    printf(" (no)");
    pc+=5;
  }
}
 
/**
* call 80 Da Db Dc Dd
*/
void call(int addr)
{
  printf("call %x", addr);
  /* make entry on stack */
  /* push old pc onto stack */
  doPsh(pc);
  pc=addr;
}
 
/* ret	90 */
void ret()
{
  printf("ret");
  pc=p[*esp];
  *esp=*esp+0x4;  /* restore pc from stack */
  pc+=5; /* for how many chars it took to call */
}
 
void doPsh(int val)
{ 
  *esp=*esp-4; /* make entry on the stack */
  loadVal(val, *esp);
}
 
/* push1 rA	A0 rAF */
void push1(Char reg)
{
  int  *rA = r1(reg);
  printf("push1 %x", *rA);
  pc+=2;
  doPsh(*rA);
}
 
void loadVal(int val, int addr)
{
  p[addr] = (Char) (val & 0xf000);
  p[addr+1] = (Char) (val & 0x0f00);
  p[addr+2] = (Char) (val & 0x00f0);
  p[addr+3] = (Char) (val & 0x000f);
}
 
/* pop1 rA	B0 rAF */
void pop1(Char reg)
{
  int *rA=r1(reg);
  *rA=p[*esp];  /* pull top stack value into rA */
  *esp=*esp+0x4;  /* remove entry from the stack */
  printf("pop1 %s %x", rA, *rA);
  pc+=2;
}
 
int printMemory(int start)
{
  int words_on_screen = 1000;
  for(int i=start; i< start+words_on_screen; i++)
  {
    if(i==(0%4))
      printf(" ");
    printf("%x\t", p[i]);
  }
  return 0;
}
 
/* Decodes the string of Char-sized characters and executes them */
int decode(Char p[])
{
  /*   
  take the first Char
    - determine how many operands
    - call function with right operands
  */
  for(pc=0; pc< programLength;)
  {
 
    printf("\n0x%x:\t", pc & 0xff);
    switch(p[pc] & 0xf0)
    {
      case 0x00:
      {
        if((p[pc] & 0x0f) == 0x0)
        {
          printf("%x\t\t", p[pc]);
          halt();
        }
        else
          printf("Error interpreting halt at pc=%x", pc);
        break;
      }
      case 0x10:
      {
        if((p[pc] & 0x0f) == 0x0)
        {
          printf("%x\t\t", p[pc]);
          nop();
        }
        else
          printf("Error interpreting nop at pc=%x", pc);
        break;
      }
      case 0x20:
      {
        printf("%x %x \t\t", p[pc] & 0xff, p[pc+1] & 0xff);
        Char reg=p[pc+1];
        /* 1=4, mov
          rrmov1 rA, rb		20 rArB
          cmov1e rA, rb		21 rArB
          cmov1 rA, rb		22 rArB
          cmove rA, rb		23 rArB
          cmovne rA, rb		24 rArB
          cmovge rA, rb		25 rArB
          cmovg rA, rb		26 rArB
         */
         switch(p[pc] & 0x0f)
         {
           case 0x0:
             rrmov1(reg);
             break;
           case 0x1:
             cmov1e(reg);
             break;
           case 0x2:
             cmov1(reg);
             break;
           case 0x3:
             cmove(reg);
             break;
           case 0x4:
             cmovne(reg);
             break;
           case 0x5:
             cmovge(reg);
             break;
           case 0x6:
             cmovg(reg);
             break;
           default:
             setINS();
             printf("Error interpretinf mov at pc=%x", pc);
             break;
         }
         break;
      }
      case 0x30:
      {
        /* l=8, irmov1 */
        /* irmov1 V,rb		30 FrB V[4] */
        if((p[pc] & 0x0f) == 0x0)
        {
          printf("%x %x %x %x %x %x\t",
                 p[pc] & 0xff,
                 p[pc+1] && 0xff,
                 p[pc+2] && 0xff,
                 p[pc+3] && 0xff,
                 p[pc+4] && 0xff,
                 p[pc+5] && 0xff);
          int val=getVal(p[pc+2], p[pc+3], p[pc+4], p[pc+5]);
          Char reg=p[pc+1];
          irmov1(val, reg);
        }
        else
        {
          setINS();
          printf("Error interpreting irmov1 at pc=%x", pc);
        }
        break;
      }
      case 0x40:
      {
        /* 1=8, rmmov1 */
        /* rmmov1 rA, D(rB)	40 rArB D[4] */
        if((p[pc] & 0x0f) == 0x0)
        {
          printf("%x %x %x %x %x %x\t", p[pc] & 0xff, p[pc+1] & 0xff,
                 p[pc+2] & 0xff, p[pc+3], p[pc+4], p[pc+5]);
          int data=getVal(p[pc+2], p[pc+3], p[pc+4], p[pc+5]);
          rmmov1(p[pc+1], data);
        }
        else
        {
          setINS();
          printf("Error interpreting rrmov1 at pc=%x", pc);
        }
        break;
      }
      case 0x50:
      {
        /* 1=8, mrmov1 */
        /* mrmov1 D(rB), rA	50 rArB D[4] */
        if((p[pc] & 0x0f) == 0x0)
        {
          printf("%x %x %x %x %x %x\t", p[pc] & 0xff, p[pc+1] & 0xff,
                 p[pc+2] & 0xff, p[pc+3] & 0xff, p[pc+4] & 0xff, p[pc+5] & 0xff);
          int data=getVal(p[pc+2], p[pc+3], p[pc+4], p[pc+5]);
          mrmov1(p[pc+1], data);
        }
        else
        {
          setINS();
          printf("Error interpreting mrmov1 at pc=%x", pc);
        }
        break;
      }
      case 0x60:
      {
        printf("%x %x \t\t", p[pc] & 0xff, p[pc+1] & 0xff);
        Char reg=p[pc+1];
        /* 1=4, op */
      /*
      add1 rA, rB	60 rArB
      sub1 rA, rB	61 rArB
      and1 rA, rB	62 rArB
      xor1 rA, rB	63 rArB
       */
        switch(p[pc] & 0x0f)
        {
          case 0x0:
            add1(reg);
            break;
          case 0x1:
            sub1(reg);
            break;
          case 0x2:
            and1(reg);
            break;
          case 0x3:
            xor1(reg);
            break;
          default:
            setINS();
            printf("Problem parsing op at pc=%x", pc);
            break;
        }
        break;
      }
      case 0x70:
      {
        /* 1=8, jmps */
        printf("%x %x %x %x %x\t", p[pc] & 0xff, p[pc+1] & 0xff,
                 p[pc+2] & 0xff, p[pc+3] & 0xff, p[pc+4] & 0xff);
        int dest=getVal(p[pc+1], p[pc+2], p[pc+3], p[pc+4]);
      /* 
      jmp Dest		70 Dest[4]
      j1e Dest		71 Dest[4]
      j1 Dest		72 Dest[4]
      je Dest		73 Dest[4]
      jne Dest		74 Dest[4]
      jge Dest		75 Dest[4]
      jg Dest		76 Dest[4]
        */
        switch(p[pc] & 0x0f)
        {
          case 0x0:
            jmp(dest);
            break;
          case 0x1:
            j1e(dest);
            break;
          case 0x2:
            j1(dest);
            break;
          case 0x3:
            je(dest);
            break;
          case 0x4:
            jne(dest);
            break;
          case 0x5:
            jge(dest);
            break;
          case 0x6:
            jg(dest);
            break;
          default:
            setINS();
            printf("Error interpreting jump at pc=%x", pc);
            break;
        } 
        break;
      }
      case 0x80:
      {
        /* 1=8, call */
        /* call	80 Dest[4] */
        if((p[pc] & 0x0f) == 0x0)
        {
          printf("%x %x %x %x %x\t", p[pc] & 0xff, p[pc+1] & 0xff,
                 p[pc+2] & 0xff, p[pc+3] & 0xff, p[pc+4] & 0xff);
          int dest=getVal(p[pc+1], p[pc+2], p[pc+3], p[pc+4]);
          call(dest);
        }
        else
        {
          setINS();
          printf("Error interpreting call at pc=%x", pc);
        }
        break;
      }
      case 0x90:
      {
        /* 1=2, ret */
        /* ret	90 */
        if((p[pc] & 0x0f) == 0x0)
        {
          printf("%x \t\t", p[pc] & 0xff);
          ret();
        }
        else
        {
          setINS();
          printf("Error interpreting ret at pc=%x", pc);
        }
        break;
      }
      case 0xa0:
      {
        /* 1=4, push */
        /* push1 rA	A0 rAF */
        if((p[pc] & 0x0f) == 0x0)
        {
          printf("%x %x \t\t", p[pc] & 0xff, p[pc+1] & 0xff);
          push1((Char) (p[pc+1] & 0xf0));
        }
        else
        {
          setINS();
          printf("Error interpreting push1 at pc=%x", pc);
        }
        break;
      }
      case 0xb0:
      {
        /* 1=4, pop1 */
        /* pop1 rA	B0 rAF */
        if((p[pc] & 0x0f) == 0x0)
        {
          printf("%x %x \t\t", p[pc] & 0xff, p[pc+1] & 0xff);
          pop1((Char)(p[pc+1] & 0xf0));
        }
        else
        {
          setINS();
          printf("Error interpreting pop1 at pc=%x", pc);
        }
        break;
      }
      default:
      {
          setINS();
          printf("Error interpreting instruction at pc=%x", pc);
      }
    }
  } 
  printRegisters();
  return 0;   
}
 
 
/* Program start */
int main(int argv, char* argc[])
{
 
  for(int p=1; p<argv; p++)
    printf("%s", argc[p]);
 
  setup();
 
  if(argv<1)
    printf("Enter the name:");
  else
  {
 
    FILE *fp;
    Char *buf;
    long fLen;
 
    fp = fopen(argc[1], "rb");
    fseek(fp, 0, SEEK_END);
    fLen = ftell(fp);
    rewind(fp);
    buf = (Char *)malloc((fLen+1)*sizeof(Char));
    fread(buf, fLen, 1, fp);
    fclose(fp);
 
    FASCII(buf);
 
    decode(buf);*/
  }
  return 0;
}
 

prog.c: In function ‘setFlags’:
prog.c:89:9: warning: implicit declaration of function ‘clearFlags’ [-Wimplicit-function-declaration]
         clearFlags();
         ^~~~~~~~~~
prog.c:93:13: warning: implicit declaration of function ‘setSF’ [-Wimplicit-function-declaration]
             setSF();
             ^~~~~
prog.c:94:45: warning: suggest parentheses around comparison in operand of ‘&’ [-Wparentheses]
         if (((a & 128) == 128 &&  (b & 128) == 128 &  (result & 128) == 0) ||
                                   ~~~~~~~~~~^~~~~~
prog.c:95:45: warning: suggest parentheses around comparison in operand of ‘&’ [-Wparentheses]
             ((a & 128) == 0   &&  (b & 128) == 0   &  (result & 128) == 128))
                                   ~~~~~~~~~~^~~~
prog.c:96:13: warning: implicit declaration of function ‘setOF’ [-Wimplicit-function-declaration]
             setOF();
             ^~~~~
prog.c: At top level:
prog.c:117:6: warning: conflicting types for ‘setSF’
 void setSF()
      ^~~~~
prog.c:93:13: note: previous implicit declaration of ‘setSF’ was here
             setSF();
             ^~~~~
prog.c:133:6: warning: conflicting types for ‘clearFlags’
 void clearFlags()
      ^~~~~~~~~~
prog.c:89:9: note: previous implicit declaration of ‘clearFlags’ was here
         clearFlags();
         ^~~~~~~~~~
prog.c:148:6: warning: conflicting types for ‘setOF’
 void setOF()
      ^~~~~
prog.c:96:13: note: previous implicit declaration of ‘setOF’ was here
             setOF();
             ^~~~~
prog.c: In function ‘getVal’:
prog.c:262:17: warning: left shift count >= width of type [-Wshift-count-overflow]
     val=val | d << 32;
                 ^~
prog.c: In function ‘rrmov1’:
prog.c:352:19: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘int *’ [-Wformat=]
   printf("rrmov1 %s, %s: (%x)", src, dst, *dst);
                   ^
prog.c:352:23: warning: format ‘%s’ expects argument of type ‘char *’, but argument 3 has type ‘int *’ [-Wformat=]
   printf("rrmov1 %s, %s: (%x)", src, dst, *dst);
                       ^
prog.c: In function ‘cmov1e’:
prog.c:366:21: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘int *’ [-Wformat=]
     printf("cmov1e %s, %s: (%x moved)", src, dst, *dst);
                     ^
prog.c:366:25: warning: format ‘%s’ expects argument of type ‘char *’, but argument 3 has type ‘int *’ [-Wformat=]
     printf("cmov1e %s, %s: (%x moved)", src, dst, *dst);
                         ^
prog.c:369:25: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘int *’ [-Wformat=]
         printf("cmov1e %s, %s: (%x not moved)", src, dst, *dst);
                         ^
prog.c:369:29: warning: format ‘%s’ expects argument of type ‘char *’, but argument 3 has type ‘int *’ [-Wformat=]
         printf("cmov1e %s, %s: (%x not moved)", src, dst, *dst);
                             ^
prog.c: In function ‘cmov1’:
prog.c:383:20: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘int *’ [-Wformat=]
     printf("cmov1 %s, %s: (%x moved)", src, dst, *dst);
                    ^
prog.c:383:24: warning: format ‘%s’ expects argument of type ‘char *’, but argument 3 has type ‘int *’ [-Wformat=]
     printf("cmov1 %s, %s: (%x moved)", src, dst, *dst);
                        ^
prog.c:386:24: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘int *’ [-Wformat=]
         printf("cmov1 %s, %s: (%x not moved)", src, dst, *dst);
                        ^
prog.c:386:28: warning: format ‘%s’ expects argument of type ‘char *’, but argument 3 has type ‘int *’ [-Wformat=]
         printf("cmov1 %s, %s: (%x not moved)", src, dst, *dst);
                            ^
prog.c: In function ‘cmove’:
prog.c:400:20: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘int *’ [-Wformat=]
     printf("cmove %s, %s: (%x moved)", src, dst, *dst);
                    ^
prog.c:400:24: warning: format ‘%s’ expects argument of type ‘char *’, but argument 3 has type ‘int *’ [-Wformat=]
     printf("cmove %s, %s: (%x moved)", src, dst, *dst);
                        ^
prog.c:403:24: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘int *’ [-Wformat=]
         printf("cmove %s, %s: (%x not moved)", src, dst, *dst);
                        ^
prog.c:403:28: warning: format ‘%s’ expects argument of type ‘char *’, but argument 3 has type ‘int *’ [-Wformat=]
         printf("cmove %s, %s: (%x not moved)", src, dst, *dst);
                            ^
prog.c: In function ‘cmovne’:
prog.c:417:21: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘int *’ [-Wformat=]
     printf("cmovne %s, %s: (%x moved)", src, dst, *dst);
                     ^
prog.c:417:25: warning: format ‘%s’ expects argument of type ‘char *’, but argument 3 has type ‘int *’ [-Wformat=]
     printf("cmovne %s, %s: (%x moved)", src, dst, *dst);
                         ^
prog.c:420:25: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘int *’ [-Wformat=]
         printf("cmovne %s, %s: (%x not moved)", src, dst, *dst);
                         ^
prog.c:420:29: warning: format ‘%s’ expects argument of type ‘char *’, but argument 3 has type ‘int *’ [-Wformat=]
         printf("cmovne %s, %s: (%x not moved)", src, dst, *dst);
                             ^
prog.c: In function ‘cmovge’:
prog.c:434:21: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘int *’ [-Wformat=]
     printf("cmovge %s, %s: (%x moved)", src, dst, *dst);
                     ^
prog.c:434:25: warning: format ‘%s’ expects argument of type ‘char *’, but argument 3 has type ‘int *’ [-Wformat=]
     printf("cmovge %s, %s: (%x moved)", src, dst, *dst);
                         ^
prog.c:437:25: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘int *’ [-Wformat=]
         printf("cmovge %s, %s: (%x not moved)", src, dst, *dst);
                         ^
prog.c:437:29: warning: format ‘%s’ expects argument of type ‘char *’, but argument 3 has type ‘int *’ [-Wformat=]
         printf("cmovge %s, %s: (%x not moved)", src, dst, *dst);
                             ^
prog.c: In function ‘cmovg’:
prog.c:451:20: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘int *’ [-Wformat=]
     printf("cmovg %s, %s: (%x moved)", src, dst, *dst);
                    ^
prog.c:451:24: warning: format ‘%s’ expects argument of type ‘char *’, but argument 3 has type ‘int *’ [-Wformat=]
     printf("cmovg %s, %s: (%x moved)", src, dst, *dst);
                        ^
prog.c:454:24: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘int *’ [-Wformat=]
         printf("cmovg %s, %s: (%x not moved)", src, dst, *dst);
                        ^
prog.c:454:28: warning: format ‘%s’ expects argument of type ‘char *’, but argument 3 has type ‘int *’ [-Wformat=]
         printf("cmovg %s, %s: (%x not moved)", src, dst, *dst);
                            ^
prog.c: In function ‘irmov1’:
prog.c:465:19: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘int *’ [-Wformat=]
   printf("irmov1 %s, %x", rB, *rB & 0xffff);
                   ^
prog.c: In function ‘rmmov1’:
prog.c:476:3: warning: implicit declaration of function ‘loadVal’ [-Wimplicit-function-declaration]
   loadVal(*rA, *rB + offset);
   ^~~~~~~
prog.c:477:19: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘int *’ [-Wformat=]
   printf("rmmov1 %s, %x(%x)", rA, offset & 0xffff, *rB & 0xffff);
                   ^
prog.c: In function ‘mrmov1’:
prog.c:489:22: warning: format ‘%s’ expects argument of type ‘char *’, but argument 3 has type ‘int *’ [-Wformat=]
   printf("mrmov1 %x(%s), %s: (%x)", offset & 0xffff, rB, rA, *rA);
                      ^
prog.c:489:27: warning: format ‘%s’ expects argument of type ‘char *’, but argument 4 has type ‘int *’ [-Wformat=]
   printf("mrmov1 %x(%s), %s: (%x)", offset & 0xffff, rB, rA, *rA);
                           ^
prog.c: In function ‘add1’:
prog.c:500:14: warning: initialization makes pointer from integer without a cast [-Wint-conversion]
   int* tmp = *dst;
              ^
prog.c:502:17: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘int *’ [-Wformat=]
   printf("add1 %s, %s: (%x)", dst, src, *dst);
                 ^
prog.c:502:21: warning: format ‘%s’ expects argument of type ‘char *’, but argument 3 has type ‘int *’ [-Wformat=]
   printf("add1 %s, %s: (%x)", dst, src, *dst);
                     ^
prog.c: In function ‘sub1’:
prog.c:514:14: warning: initialization makes pointer from integer without a cast [-Wint-conversion]
   int* tmp = *dst;
              ^
prog.c:516:17: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘int *’ [-Wformat=]
   printf("sub1 %s, %s: (%x)", dst, src, *dst);
                 ^
prog.c:516:21: warning: format ‘%s’ expects argument of type ‘char *’, but argument 3 has type ‘int *’ [-Wformat=]
   printf("sub1 %s, %s: (%x)", dst, src, *dst);
                     ^
prog.c:514:8: warning: unused variable ‘tmp’ [-Wunused-variable]
   int* tmp = *dst;
        ^~~
prog.c: In function ‘and1’:
prog.c:529:17: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘int *’ [-Wformat=]
   printf("and1 %s, %s: (%x)", dst, src, *dst);
                 ^
prog.c:529:21: warning: format ‘%s’ expects argument of type ‘char *’, but argument 3 has type ‘int *’ [-Wformat=]
   printf("and1 %s, %s: (%x)", dst, src, *dst);
                     ^
prog.c: In function ‘xor1’:
prog.c:543:17: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘int *’ [-Wformat=]
   printf("xor1 %s, %s: (%x)", dst, src, *dst);
                 ^
prog.c:543:21: warning: format ‘%s’ expects argument of type ‘char *’, but argument 3 has type ‘int *’ [-Wformat=]
   printf("xor1 %s, %s: (%x)", dst, src, *dst);
                     ^
prog.c: In function ‘call’:
prog.c:675:3: warning: implicit declaration of function ‘doPsh’ [-Wimplicit-function-declaration]
   doPsh(pc);
   ^~~~~
prog.c: At top level:
prog.c:688:6: warning: conflicting types for ‘doPsh’
 void doPsh(int val)
      ^~~~~
prog.c:675:3: note: previous implicit declaration of ‘doPsh’ was here
   doPsh(pc);
   ^~~~~
prog.c:703:6: warning: conflicting types for ‘loadVal’
 void loadVal(int val, int addr)
      ^~~~~~~
prog.c:476:3: note: previous implicit declaration of ‘loadVal’ was here
   loadVal(*rA, *rB + offset);
   ^~~~~~~
prog.c: In function ‘pop1’:
prog.c:717:17: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘int *’ [-Wformat=]
   printf("pop1 %s %x", rA, *rA);
                 ^
prog.c: In function ‘main’:
prog.c:1055:18: error: expected expression before ‘/’ token
     decode(buf);*/
                  ^

Standard output is empty