Restructure

emulator/include/obj.h

@@ -0,0 +1,210 @@
+/*******************************************************************************
+ HARPtools by Chad D. Kersey, Summer 2011
+*******************************************************************************/
+#ifndef __OBJ_H
+#define __OBJ_H
+
+#include <iostream>
+#include <string>
+#include <vector>
+#include <list>
+#include <stdlib.h>
+
+#include "types.h"
+#include "archdef.h"
+#include "instruction.h"
+#include "enc.h"
+#include "asm-tokens.h"
+
+namespace Harp {
+  class Decoder;
+  class Encoder;
+
+  class Ref {
+  public:
+    std::string name;
+    Ref(const std::string &n, bool r, Size ib = 0): 
+      name(n), bound(false), relative(r), ibase(ib) { }
+    virtual ~Ref() { }
+    virtual void bind(Addr addr, Addr base = 0) = 0;
+    virtual Addr getAddr() const = 0;
+
+    bool bound, relative;
+    Size ibase;
+  };
+
+  /* Used in not-yet-encoded code objects, plain old data. */
+  class SimpleRef : public Ref {
+  public:
+    SimpleRef(const std::string &name, Addr &addr, bool rel = false) : 
+      Ref(name, rel), addr(addr) { }
+    virtual void bind(Addr addr, Addr base = 0) {
+      std::cout << "Attempted to bind a SimpleRef.\n";
+      exit(1);
+    } 
+    virtual Addr getAddr() const { return this->addr; }
+    Byte *getAddrPtr() { return (Byte*)&addr; }
+
+  private:
+    Addr &addr;
+  };
+
+//   /* Used in already-encoded code objects. */
+//   class OffsetRef : public Ref {
+//   public:
+//     OffsetRef(
+//       const std::string &name, std::vector<Byte> &v, Size offset, Size bits,
+//       Size ws, bool rel = false, Size ibase = 0
+//     ) : Ref(name, rel, ibase), data(v), offset(offset), bits(bits), wordSize(ws)
+//     {}
+
+//     virtual void bind(Addr addr, Addr base = 0) {
+//       Size bytes(bits/8), remainder(bits%8);
+
+//       if (relative) {
+//         addr = addr - base;
+//         Word_s addr_s(addr);
+//         if ((addr_s >> bits) != ~0ull && (addr_s >> bits) != 0) goto noFit;
+//       } else {
+//         Addr mask = (1ull<<bits)-1;
+//         if (addr > mask) goto noFit;
+//       }
+
+//       { Byte mask((1ull<<remainder) - 1);
+//         Size i;
+//         for (i = 0; i < bytes; i++) {
+//           data[offset+i] = addr & 0xff;
+//           addr >>= 8;
+//         }
+//         data[offset+i] &= ~mask;
+//         data[offset+i] |= (addr&mask);
+//         bound = true; 
+//       }
+
+//       return;
+//     noFit:
+//       std::cout << "Attempt to bind a " << bits << "-bit "
+//                 << (relative?"":"non-") << "relative symbol to an address"
+//                                            " it cannot reach.\n";
+//       exit(1);
+//     }
+
+//     virtual Addr getAddr() const {
+//       Size bytes = bits/8, remainder = bits%8;
+//       Byte mask((1<<remainder)-1);
+//       Addr a(data[offset]&mask);
+
+//       for (Size i = 0; i < bytes-1; i++) {
+//         a |= data[offset + bytes - i - 1];
+//         a <<= 8;
+//       }
+//       return a;
+//     }
+
+//     Size getOffset() const { return offset; }
+//     Size getBits() const { return bits; }
+
+//   private:
+//     std::vector<Byte> &data;
+//     Size offset, bits, wordSize;
+//   };
+
+//   class Chunk { 
+//   public:
+//     Chunk(std::string n, Size a = 0, Word f = 0) : 
+//       name(n), alignment(a), bound(false), flags(f), global(false) {}
+//     virtual ~Chunk() { for (Size i = 0; i < refs.size(); i++) delete refs[i]; }
+//     void bind(Addr a) { address = a; bound = true; }
+//     void setGlobal() { global = true; }
+//     bool isGlobal() const { return global; }
+//     std::string name;
+//     Size alignment;
+//     bool bound, global;
+//     Addr address;
+//     Word flags;
+//     std::vector<Ref*> refs;    
+//   };
+
+//   class TextChunk : public Chunk {
+//   public:
+//     TextChunk(std::string n, Size a = 0, Word f = 0) 
+//       : Chunk(n, a, f), instructions() {}
+
+//     ~TextChunk() { 
+//       for (Size i = 0; i < instructions.size(); i++) delete instructions[i]; 
+//     }
+
+//     std::vector<Instruction*> instructions;
+//   };
+
+//   class DataChunk : public Chunk {
+//   public:
+//     DataChunk(std::string n, Size a = 0, Word f = 0) 
+//       : Chunk(n, a, f), size(0), contents() {}
+//     Size size;
+//     std::vector<Byte> contents; /* 0 to size bytes in length. */
+//   };
+
+//   class Obj {
+//   public:
+//     ~Obj() { for (Size i = 0; i < chunks.size(); i++) delete chunks[i]; }
+//     std::vector<Chunk*> chunks;
+//     Size entry;
+//   };
+
+//   class DynObj : public Obj {
+//   public:
+//     std::vector<std::string> deps;
+//   };
+
+//   class ObjReader {
+//   public:
+//     virtual Obj *read(std::istream &input) = 0;
+//   private:
+//   };
+
+//   class ObjWriter {
+//   public:
+//     virtual void write(std::ostream &output, const Obj &o) = 0;
+//   private:
+//   };
+
+//   class AsmReader : public ObjReader {
+//   public:
+//     AsmReader(ArchDef arch) :
+//       wordSize(arch.getWordSize()), nRegs(arch.getNRegs()) {}
+//     virtual Obj *read(std::istream &input);
+//   private:
+//     Size wordSize, nRegs;
+
+//     // Operand type sequences indexed by argument class
+//     enum ArgType {AT_END, AT_REG, AT_PREG, AT_LIT};
+//     static ArgType operandtype_table[][4]; // ArgClass -> ArgType[arg_idx]
+//   };
+   
+//   class HOFReader : public ObjReader {
+//   public:
+//     HOFReader(ArchDef &arch) : arch(arch) {}
+//     Obj *read(std::istream &input);
+//   private:
+//     const ArchDef &arch;
+//   };
+
+//   class AsmWriter : public ObjWriter {
+//   public:
+//     AsmWriter(ArchDef arch): wordSize(arch.getWordSize()) {}
+//     virtual void write(std::ostream &output, const Obj &obj);
+//   private:
+//     Size wordSize;
+//   };
+ 
+//   class HOFWriter : public ObjWriter {
+//   public:
+//     HOFWriter(ArchDef &arch) : arch(arch) {}
+//     virtual void write(std::ostream &output, const Obj &obj);
+//   private:
+//     const ArchDef &arch;
+//   };
+};
+
+#endif