Subversion Repositories i650

//////////////////////////////////////////////////////////////////////////////////

// IBM 650 Reconstruction in Verilog (i650)

// 

// This file is part of the IBM 650 Reconstruction in Verilog (i650) project

// http:////www.opencores.org/project,i650

//

// Description: An implementation of SOAP 2 for the IBM 650.

// 

// Additional Comments: .

//

// Copyright (c) 2015 Robert Abeles

//

// This source file is free software; you can redistribute it

// and/or modify it under the terms of the GNU Lesser General

// Public License as published by the Free Software Foundation;

// either version 2.1 of the License, or (at your option) any

// later version.

//

// This source is distributed in the hope that it will be

// useful, but WITHOUT ANY WARRANTY; without even the implied

// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

// PURPOSE.  See the GNU Lesser General Public License for more

// details.

//

// You should have received a copy of the GNU Lesser General

// Public License along with this source; if not, download it

// from http://www.opencores.org/lgpl.shtml

//////////////////////////////////////////////////////////////////////////////////

#ifndef ibm650_soap2_soap2_h

#define ibm650_soap2_soap2_h

#include <string>

#include <iostream>

#include <fstream>

#include <sstream>

#include <iomanip>

#include <vector>

#include <map>

#include "ibm_codec.h"

using namespace std;

struct region {

    u_int8_t  code;

    u_int32_t start;

    region(u_int8_t c, u_int32_t s) : code(c), start(s) {}

};

struct symbol {

    string            name;

    u_int32_t         location;

    vector<u_int32_t> ref_line;

    symbol(string n, u_int32_t l, u_int32_t r) : name(n), location(l) {

        ref_line.push_back(r);

    }

    void add_ref(u_int32_t r) {ref_line.push_back(r);}

};

enum {

    real_op,

    alias_op,

    unused_op,

    pseudo_op,

    final_op

};

enum {

    pseudo_alf = 1000,

    pseudo_bla,

    pseudo_blr,

    pseudo_bop,

    pseudo_equ,

    pseudo_hed,

    pseudo_pat,

    pseudo_rbr,

    pseudo_reg,

    pseudo_rel,

    pseudo_req,

    pseudo_syn

};

enum {

    asmflag_c = 0x0001,

    asmflag_e = 0x0002,

    asmflag_p = 0x0004,

    asmflag_k = 0x0008

};

struct opcode {

    string    op;

    u_int32_t code;

    u_int32_t group;

    u_int32_t d_even;

    u_int32_t d_odd;

    u_int32_t i_even;

    u_int32_t i_odd;

    u_int32_t type;

    string    alias;

    opcode(const string& o, u_int32_t c, u_int32_t g,u_int32_t de, u_int32_t dodd, u_int32_t ie, u_int32_t io, u_int32_t t)

     : op(o)

     , code(c)

     , group(g)

     , d_even(de)

     , d_odd(dodd)

     , i_even(ie)

     , i_odd(io)

     , type(t)

    {}

    opcode(const string& o, const string& a) : op(o), alias(a), type(alias_op) {}

    inline bool opt_A() const {return (8 == (group / 100));}

    inline bool opt_B() const {return (8 == ((group / 10) % 10));}

    inline bool opt_C() const {return (8 == (group % 10));}

};

enum fieldtype {

    field_blank,

    field_symbolic,

    field_numeric,

    field_region,

    field_error

};

struct asmfield {

    string    src;

    fieldtype type;

    u_int32_t nval;

    string    symbol;

    u_int8_t  region;

    asmfield(const string&, u_int8_t);

};

class biq_number {

    u_int64_t val;

  public:

    biq_number(const biq_number &n) {val = n.val;}

    biq_number(bool s, u_int64_t v) {

        val = (((s)? 1LL : 0LL) << 63) | (v % 10000000000LL);

    }

    biq_number() : val(0) {}

    bool sign() const {return (val & 0x8000000000000000LL);}

    u_int64_t value() const {return (val & 0x7fffffffffffffffLL);}

    void set_sign(bool s) {

        val = (val & 0x7fffffffffffffffLL) | (((s)? 1LL : 0LL) << 63);

    }

    void set_value(u_int64_t v) {

        val = (val & 0x8000000000000000LL) | (v % 10000000000LL);

    }

};

class memory {

    vector<biq_number> mem;

public:

    memory(u_int32_t sz) : mem(sz) {}

    void load_7wd_deck(istream &);

    biq_number& operator[](unsigned ix) {ix %= mem.size(); return mem[ix];}

};

class memmap {

    u_int32_t size;

    u_int32_t origin;

    vector<int> allocmap;

    int32_t freectr;

public:

    memmap(u_int32_t s, u_int32_t o);

    void reserve(u_int32_t addr);

    void reserve(u_int32_t fwa, u_int32_t sz);

    void unreserve(u_int32_t addr);

    void unreserve(u_int32_t fwa, u_int32_t sz);

    void reset();

    int32_t optimum(u_int32_t rot);

    inline bool isfull() const {return (freectr <= 0);}

    inline bool isvalid(u_int32_t addr) const {return (addr >= origin) && (addr < (origin+size));}

    inline bool isvalid(u_int32_t fwa, u_int32_t sz) const { return (fwa >= origin) && ((fwa + sz - 1) < (origin+size));}

    void print_availtab(ostream &);

};

enum addr_type {

    addr_gs,

    addr_ias,

    addr_800X,

    addr_invalid

};

class soap2 {

    typedef map<string, symbol*>::iterator symiter;

    map<string, symbol*>   symboltab;   // symbol -> location

    typedef map<u_int8_t, region*>::iterator regiter;

    map<u_int8_t, region*> regiontab;   // character -> region

    memmap                 gsmap;       // general storage (drum) allocation map

    map<string, opcode*>   opcodetab;   // opcode lookup table

    typedef map<string, opcode*>::iterator opiter;

    vector<opcode*>        opbycodetab; // opcode indexed by opcode

    istream               &input_deck;

    istream               &check_deck;

    ostream               &output_deck;

    ostream               &listing;

    memory                 ibm_obj;

    ibm_codec              codec;

    int                    flags;

    void init_opcodetab();

    ostringstream    errors;

    u_int32_t cardnumber;

    u_int8_t  hed_char;

    int32_t   opt_addr;

    int32_t   opt_gs;

    int32_t   opt_ias;

    int32_t   opt_800x;

    int32_t   opt_b;

    // statement currently under assembly

    string    src;

    string    src_type;

    string    src_sign;

    string    src_loc;

    string    src_op;

    string    src_d;

    string    src_dtag;

    string    src_i;

    string    src_itag;

    string    src_comm;

    string    src_fcom;

    u_int32_t asm_loc;

    u_int32_t asm_op;

    u_int32_t asm_d;

    u_int32_t asm_i;

    opcode   *op;

    bool blank_loc;

    bool blank_op;

    bool blank_d;

    bool blank_i;

    bool punch_800x;

    bool bypass;

    enum opt_type {

        opt_d,

        opt_i,

    };

    u_int32_t find_optimal_wt(opt_type);

    u_int32_t find_optimal_800x(opt_type, u_int32_t);

    void process_loc();

    void process_loc_addr();

    void process_op();

    void process_d();

    void process_d_addr();

    void process_i();

    void process_i_addr();

    void assemble();

    void assemble_statement();

    void assemble_command();

    void assemble_comment();

    void assemble_relocate();

    void assemble_realop();

    void assemble_pseudo();

    void check_obj(ostream &);

    void punch_comment(ostream &);

    void punch_command(ostream &);

    void print_comment(ostream &);

    void print_command(ostream &);

    void print_symtab(ostream &);

    void print_availtab(ostream &);

    void print_regiontab(ostream &);

    void error_message(const string &);

public:

    soap2(int, int, istream &, ostream &, ostream &, istream &);

    inline u_int8_t ascii_to_650(int c) const {

      return codec.valid_code650_for_ascii(c)? codec.ascii_to_code650(c) : 0;

    }

};

#endif