diff --git a/lib/caotral/assembler.rb b/lib/caotral/assembler.rb
index 89e0733..f889178 100644
--- a/lib/caotral/assembler.rb
+++ b/lib/caotral/assembler.rb
@@ -1,9 +1,9 @@
 # frozen_string_literal: true
-require_relative "assembler/elf"
-require_relative "assembler/elf/utils"
-require_relative "assembler/elf/header"
-require_relative "assembler/elf/sections"
-require_relative "assembler/elf/section_header"
+require "caotral/binary/elf"
+
+require_relative "assembler/builder"
+require_relative "assembler/reader"
+require_relative "assembler/writer"
 
 class Caotral::Assembler
   GCC_ASSEMBLERS = ["gcc", "as"].freeze
@@ -15,7 +15,7 @@ def self.assemble!(input:, output: File.basename(input, ".*") + ".o", assembler:
 
   def initialize(input:, output: File.basename(input, ".*") + ".o", assembler: "as", type: :relocatable, debug: false)
     @input, @output = input, output
-    @elf = ELF.new(type:, input:, output:, debug:)
+    @asm_reader = Caotral::Assembler::Reader.new(input:, debug:)
     @assembler = assembler
     @debug = debug
   end
@@ -30,7 +30,10 @@ def assemble(assembler: @assembler, assembler_options: [], input: @input, output
     output
   end
   def obj_file = @output
-  def to_elf(input: @input, output: @output, debug: false) = @elf.build(input:, output:, debug:)
+  def to_elf(input: @input, output: @output, debug: false)
+    elf_obj = Caotral::Assembler::Builder.new(instructions:).build
+    Caotral::Assembler::Writer.new(elf_obj:, output:, debug:).write
+  end
 
   def command(asm)
     case asm
@@ -44,6 +47,7 @@ def command(asm)
   end
 
   private
+  def instructions = @instructions ||= @asm_reader.read
   def gcc_assembler(assembler)
     case assembler
     when "as", "gcc"
diff --git a/lib/caotral/assembler/builder.rb b/lib/caotral/assembler/builder.rb
new file mode 100644
index 0000000..bffa179
--- /dev/null
+++ b/lib/caotral/assembler/builder.rb
@@ -0,0 +1,50 @@
+require "caotral/binary/elf"
+
+require_relative "builder/text"
+
+module Caotral
+  class Assembler
+    class Builder
+      def initialize(instructions:) = @instructions = instructions
+
+      def build
+        elf = Caotral::Binary::ELF.new
+        elf.header = Caotral::Binary::ELF::Header.new
+
+        sections = []
+        sections << [nil, nil]
+        sections << [".text", assemble_text(@instructions)]
+        sections << [".strtab", Caotral::Binary::ELF::Section::Strtab.new]
+        sections << [".symtab", Caotral::Binary::ELF::Section::Symtab.new]
+        sections << [".shstrtab", Caotral::Binary::ELF::Section::Strtab.new]
+        sections.each do |(section_name, body)|
+          header = Caotral::Binary::ELF::SectionHeader.new
+          section = Caotral::Binary::ELF::Section.new(header:, body:, section_name:)
+          elf.sections << section
+        end
+        strtab = elf.find_by_name(".strtab")
+        symtab = elf.find_by_name(".symtab")
+        symtab.body = build_symtab(strtab.body)
+        elf
+      end
+
+      private
+      def assemble_text(instructions)
+        text = Caotral::Assembler::Builder::Text.new(instructions:)
+        instructions.each do |label, lines|
+          text.entries << { label:, size: 0 }
+          lines.each { |line| text.assemble!(line) }
+        end
+        text.build
+      end
+
+      def build_symtab(strtab)
+        entries = []
+        entries << Caotral::Binary::ELF::Section::Symtab.new.set!(name: 0, info: 0, shndx: 0, value: 0, size: 0)
+        name = strtab.offset_of("main")
+        entries << Caotral::Binary::ELF::Section::Symtab.new.set!(name:, info: 0x12, other: 0, shndx: 1, value: 0, size: 0)
+        entries
+      end
+    end
+  end
+end
diff --git a/lib/caotral/assembler/builder/text.rb b/lib/caotral/assembler/builder/text.rb
new file mode 100644
index 0000000..b4d0249
--- /dev/null
+++ b/lib/caotral/assembler/builder/text.rb
@@ -0,0 +1,275 @@
+require "caotral/binary/elf"
+module Caotral
+  class Assembler
+    class Builder
+      class Text
+        PREFIX = {
+          REX_W: 0x48,
+        }.freeze
+
+        REGISTER_CODE = {
+          RAX: 0b000,
+          RCX: 0b001,
+          RDX: 0b010,
+          RBX: 0b011,
+          RSP: 0b100,
+          RBP: 0b101,
+          RSI: 0b110,
+          RDI: 0b111,
+        }.freeze
+
+        OPECODE = {
+          ADD:  [0x01],
+          CMP:  [0x39],
+          CQO:  [0x99],
+          IDIV: [0xf7],
+          IMUL: [0x0f],
+          MOV:  [0x89],
+          MOVR: [0x8B],
+          MOVXZ: [0x0f, 0xb7],
+          SUB: [0x83],
+          XOR: [0x31],
+        }.freeze
+        HEX_PATTERN = /\A0x[0-9a-fA-F]+\z/.freeze
+        attr_reader :entries
+
+        def initialize(instructions:)
+          @instructions = instructions
+          @entries = []
+          @label_positions = {}
+        end
+
+        def assemble!(line)
+          line = line.strip
+          return if line.empty?
+          @entries << parse_line(line)
+        end
+
+        def build
+          @label_positions.clear
+          offset = 0
+          @entries.each do |entry|
+            if entry[:label]
+              @label_positions[entry[:label]] = offset
+              next
+            end
+            offset += entry[:size]
+          end
+
+          @bytes = []
+          offset = 0
+          @entries.each do |entry|
+            next if entry[:label]
+            bytes = encode(entry, offset)
+            @bytes << bytes
+            offset += bytes.size
+          end
+
+          @bytes.flatten.pack("C*")
+        end
+
+        def size = build.bytesize
+        def align(val, bytes) = (val << [0] until build.bytesize % bytes == 0)
+
+        private
+
+        def encode(entry, offset)
+          opecode(entry[:op], offset, *entry[:operands])
+        end
+
+        def parse_line(line)
+          op, *operands = line.split(/\s+/).reject(&:empty?).map { it.gsub(/,/, "") }
+          size = instruction_size(op, *operands)
+          { op:, operands:, size: }
+        end
+
+        def instruction_size(op, *operands)
+          case op
+          when "je", "jne"
+            6
+          when "jmp"
+            5
+          else
+            opecode(op, 0, *operands).size
+          end
+        end
+
+        def opecode(op, offset, *operands)
+          case op
+          when "push"
+            push(*operands)
+          when "mov", "movzb"
+            [PREFIX[:REX_W], *mov(op, *operands)]
+          when "sub", "add", "imul", "cqo", "idiv"
+            [PREFIX[:REX_W], *calc(op, *operands)]
+          when "xor"
+            [PREFIX[:REX_W], *calc_bit(op, *operands)]
+          when "lea"
+            [PREFIX[:REX_W], *calc_addr(op, *operands)]
+          when "pop"
+            pop(*operands)
+          when "cmp"
+            [PREFIX[:REX_W], *cmp(op, *operands)]
+          when "sete", "setl"
+            sete(op, *operands)
+          when "je", "jmp", "jne"
+            jump(op, offset, *operands)
+          when "syscall"
+            [0x0f, 0x05]
+          when "ret"
+            [0xc3]
+          else
+            raise Caotral::Binary::ELF::Error, "yet implemented operations: #{op}"
+          end
+        end
+
+        def jump(op, offset, *operands)
+          label = operands.first
+          target = @label_positions.fetch(label) do
+            raise Caotral::Binary::ELF::Error, "unknown label: #{label}"
+          end
+          size = instruction_size(op, label)
+          rel = Integer(target) - Integer(offset) - Integer(size)
+          displacement = [rel].pack("l<").bytes
+          case op
+          when "je"
+            [0x0f, 0x84, *displacement]
+          when "jmp"
+            [0xe9, *displacement]
+          when "jne"
+            [0x0f, 0x85, *displacement]
+          else
+            raise Caotral::Binary::ELF::Error, "unknown jump: #{op}"
+          end
+        end
+
+        def mov(op, *operands)
+          reg = case operands
+                in ["rax", "rbp"]
+                  [0xe8]
+                in ["rbp", "rsp"]
+                  [0xe5]
+                in ["rsp", "rbp"]
+                  [0xec]
+                in ["[rax]", "rdi"]
+                  [0x38]
+                in ["rax", "al"]
+                  op = "MOVXZ"
+                  [0xc0]
+                in ["rax", "[rax]"]
+                  op = "MOVR"
+                  [0x00]
+                in ["rdi", "rax"]
+                  [0xC7]
+                in ["rax", HEX_PATTERN]
+                  return [0xC7, 0xC0, *immediate(operands[1])]
+                else
+                  operands&.map { reg(_1) }
+                end # steep:ignore
+          [OPECODE[op.upcase.to_sym], reg].flatten
+        end
+
+        def calc(op, *operands)
+          ope_code = OPECODE[op.upcase.to_sym]
+          case [op, *operands]
+          in ["sub", "rax", "rdi"]
+            [0x29, 0xf8]
+          in ["add", "rax", "rdi"]
+            [ope_code, 0xf8]
+          in ["imul", "rax", "rdi"]
+            [ope_code, 0xaf, 0xc7]
+          in ["idiv", "rdi"]
+            [ope_code, 0xff]
+          in ["sub", "rsp", *num]
+            [ope_code, 0xec, *num.map { |n| n.to_i(16) }]
+          in ["sub", "rax", *num]
+            [ope_code, 0xe8, *num.map { |n| n.to_i(16) }]
+          in ["cqo"]
+            [0x99]
+          end # steep:ignore
+        end
+
+        def calc_bit(op, *operands)
+          case [op, *operands]
+          in ["xor", "rax", "rax"]
+            [0x31, 0xc0]
+          in ["xor", "rdi", "rdi"]
+            [0x31, 0xff]
+          end # steep:ignore
+        end
+
+        def calc_addr(op, *operands)
+          case [op, *operands]
+          in ["lea", "rax", *addrs]
+            rm, disp = parse_addressing_mode(addrs.first)
+            [0x8D, *mod_rm(0b01, 0b000, rm), disp]
+          end # steep:ignore
+        end
+
+        def cmp(op, *operands)
+          case operands
+          in ["rax", "rdi"]
+            [0x39, 0xf8]
+          in ["rax", "0"]
+            [0x83, 0xf8, 0x00]
+          end # steep:ignore
+        end
+
+        def sete(op, *operands)
+          case [op, operands]
+          in ["sete", ["al"]]
+            [0x0f, 0x94, 0xc0]
+          in ["setl", ["al"]]
+            [0x0f, 0x9c, 0xc0]
+          end # steep:ignore
+        end
+
+        def push(*operands)
+          case operands
+          in ["rbp"] | ["rdi"]
+            [0x55]
+          in ["rax"]
+            [0x50]
+          in [HEX_PATTERN]
+            [0x68, *immediate(operands.first)]
+          else
+            [0x6a, *operands.map { |o| reg(o) }]
+          end # steep:ignore
+        end
+
+        def pop(*operands)
+          case operands
+          in ["rax"] | ["rdi"]
+            [0x58 + REGISTER_CODE[operands.first.upcase.to_sym]]
+          in ["rbp"]
+            [0x5d]
+          end # steep:ignore
+        end
+
+        def reg(r)
+          case r
+          when "rsp"
+            0xec
+          when "rbp"
+            0x5e
+          when "rax"
+            0x29
+          when "rdi"
+            0xf8
+          when /\d+/
+            r.to_i(16)
+          else
+            raise Caotral::Binary::ELF::Error, "yet implemented operand address: #{r}"
+          end
+        end
+        def immediate(operand) = [operand.to_i(16)].pack("L").unpack("C*")
+        def mod_rm(mod, reg, rm) = (mod << 6) | (reg << 3) | rm
+        def parse_addressing_mode(str)
+          m = str.match(/\[(?<reg>\w+)(?<disp>[\+\-]\d+)?\]/)
+          [REGISTER_CODE[m[:reg].upcase.to_sym], m[:disp].to_i & 0xff]
+        end
+      end
+    end
+  end
+end
+
diff --git a/lib/caotral/assembler/elf.rb b/lib/caotral/assembler/elf.rb
deleted file mode 100644
index d1f3411..0000000
--- a/lib/caotral/assembler/elf.rb
+++ /dev/null
@@ -1,77 +0,0 @@
-class Caotral::Assembler
-  class ELF
-    class Error < StandardError; end
-    class Section; end
-    class SectionHeader; end
-    module Utils; end
-
-    def initialize(type:, input:, output:, debug:)
-      @input, @output = input, output
-      @header = Header.new(type:)
-      @sections = Sections.new
-    end
-
-    def build(input: @input, output: @output, debug: false)
-      program_size = 0
-      read!(input:)
-      init_assemble!
-
-      offset = 0x40
-      section_headers = []
-      names = []
-      bodies = {
-        null: nil,
-        text: nil,
-        data: nil,
-        bss: nil,
-        note: nil,
-        symtab: nil,
-        strtab: nil,
-        shstrtab: nil,
-      }
-      name_idx = 0
-      padding = nil
-      @sections.each do |section|
-        name = section.name
-        names << name
-        section.body.set!(name: names.join) if name == "\0.shstrtab"
-        bin = section.body.build
-        size = bin.bytesize
-        bin << "\0" until (bin.bytesize % 8) == 0 if ["\0.text", "\0.shstrtab"].include?(name)
-        bin << "\0" until ((bin.bytesize + offset) % 8) == 0 if ["\0.shstrtab"].include?(name)
-        bodies[section.section_name.to_sym] = bin
-        header = section.header
-        if offset > 0x40 && size > 0 && padding&.>(0)
-          offset += padding
-          padding = nil
-        end
-        padding = bin.size - size if size > 0
-        header.set!(name: name_idx, offset:, size:) unless name == ""
-        offset += size
-        section_headers << header.build
-        name_idx += name == "" ? 1 : name.size
-      end
-      @header.set!(shoffset: offset + padding)
-      w = File.open(output, "wb")
-      w.write([@header.build, *bodies.values, *section_headers].join)
-      w.close
-      [@header.build, *bodies.values, *section_headers]
-    end
-
-    private
-    def init_assemble! = (note!; symtab!)
-
-    def read!(input: @input, text: @sections.text.body)
-      read = { main: false }
-      File.open(input, "r") do |r|
-      r.each_line do |line|
-        read[:main] = line.match(/main:/) unless read[:main]
-        next unless read[:main] && !/main:/.match(line)
-        text.assemble!(line)
-      end
-      end
-    end
-    def note! = @sections.note.body.null!
-    def symtab! = @sections.symtab.body.set!(entsize: 0x18, name: 1, info: 0x10, other: 0, shndx: 1)
-  end
-end
diff --git a/lib/caotral/assembler/elf/header.rb b/lib/caotral/assembler/elf/header.rb
deleted file mode 100644
index aefd134..0000000
--- a/lib/caotral/assembler/elf/header.rb
+++ /dev/null
@@ -1,62 +0,0 @@
-require_relative "../elf"
-
-class Caotral::Assembler::ELF::Header
-  include Caotral::Assembler::ELF::Utils
-  IDENT = [0x7f, 0x45, 0x4c, 0x46, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00].freeze
-  ELF_FILE_TYPE = { NONE: 0, REL: 1, EXEC: 2, DYN: 3, CORE: 4 }.freeze
-
-  def initialize(endian: :littel, type: :rel, arc: :amd64)
-    @ident = IDENT
-    @type = num2bytes(ELF_FILE_TYPE[elf(type)], 2)
-    @arch = arch(arc)
-    @version = num2bytes(1, 4)
-    @entry = num2bytes(0x00, 8)
-    @phoffset = num2bytes(0x00, 8)
-    @shoffset = num2bytes(0x00, 8)
-    @flags = num2bytes(0x00, 4)
-    @ehsize = num2bytes(0x40, 2)
-    @phsize = num2bytes(0x00, 2)
-    @phnum = num2bytes(0x00, 2)
-    @shentsize = num2bytes(0x40, 2)
-    @shnum = num2bytes(0x08, 2)
-    @shstrndx = num2bytes(0x07, 2)
-  end
-
-  def build = bytes.flatten.pack("C*")
-
-  def set!(entry: nil, phoffset: nil, shoffset: nil, shnum: nil, shstrndx: nil)
-    @entry = num2bytes(entry, 8) if check(entry, 8)
-    @phoffset = num2bytes(phoffset, 8) if check(phoffset, 8)
-    @shoffset = num2bytes(shoffset, 8) if check(shoffset, 8)
-    @shnum = num2bytes(shnum, 4) if check(shnum, 4)
-    @shstrndx = num2bytes(shstrndx, 4) if check(shstrndx, 4)
-  end
-
-  private
-
-  def bytes = [
-    @ident, @type, @arch, @version, @entry, @phoffset,
-    @shoffset, @flags, @ehsize, @phsize, @phnum, @shentsize,
-    @shnum, @shstrndx
-  ]
-
-  def arch(machine)
-    case machine.to_s
-    in "amd64" | "x86_64" | "x64"
-      [0x3e, 0x00]
-    end
-  end
-
-  def elf(type)
-    case type.to_s
-    in "relocatable" | "rel"
-      :REL
-    in "exe" | "ex" | "exec"
-      :EXEC
-    in "shared" | "share" | "dynamic" | "dyn"
-      :DYN
-    else
-      :NONE
-    end
-  end
-end
diff --git a/lib/caotral/assembler/elf/section.rb b/lib/caotral/assembler/elf/section.rb
deleted file mode 100644
index a1080b5..0000000
--- a/lib/caotral/assembler/elf/section.rb
+++ /dev/null
@@ -1,25 +0,0 @@
-require_relative "section/text"
-require_relative "section/bss"
-require_relative "section/data"
-require_relative "section/note"
-require_relative "section/null"
-require_relative "section/symtab"
-require_relative "section/strtab"
-require_relative "section/shstrtab"
-require_relative "section_header"
-
-class Caotral::Assembler::ELF::Section
-  attr_reader :header, :body, :name, :section_name
-  def initialize(type:, options: {})
-    type_string = type.to_s.capitalize
-    type_string = type_string.upcase if type_string == "Bss"
-    @section_name = type_string.downcase
-    @name = section_name == "null" ? "" : "\0.#{section_name}" 
-    @header = Caotral::Assembler::ELF::SectionHeader.new.send("#{@section_name}!")
-    @body = Module.const_get("Caotral::Assembler::ELF::Section::#{type_string}").new(**options)
-  end
-
-  def name=(name)
-    @name = name
-  end
-end
diff --git a/lib/caotral/assembler/elf/section/bss.rb b/lib/caotral/assembler/elf/section/bss.rb
deleted file mode 100644
index 87da36a..0000000
--- a/lib/caotral/assembler/elf/section/bss.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-class Caotral::Assembler::ELF::Section::BSS
-  include Caotral::Assembler::ELF::Utils
-  def initialize(**opts) = nil
-  def build = bytes.flatten.pack("C*")
-  def set! = self
-
-  private
-  def bytes = []
-  def check(val, bytes) = false
-end
diff --git a/lib/caotral/assembler/elf/section/data.rb b/lib/caotral/assembler/elf/section/data.rb
deleted file mode 100644
index ecf8d9a..0000000
--- a/lib/caotral/assembler/elf/section/data.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-class Caotral::Assembler::ELF::Section::Data
-  include Caotral::Assembler::ELF::Utils
-  def initialize(**opts) = nil
-  def build = bytes.flatten.pack("C*")
-  def set! = self
-  private def bytes = []
-end
diff --git a/lib/caotral/assembler/elf/section/note.rb b/lib/caotral/assembler/elf/section/note.rb
deleted file mode 100644
index ece321c..0000000
--- a/lib/caotral/assembler/elf/section/note.rb
+++ /dev/null
@@ -1,33 +0,0 @@
-class Caotral::Assembler::ELF::Section::Note
-  include Caotral::Assembler::ELF::Utils
-
-  def self.gnu_property = new.gnu_property!.build
-  def self.null = new.null!.build
-
-  def initialize(type: nil)
-    @nsize = nil
-    @dsize = nil
-    @type = nil
-    @name = nil
-    @desc = nil
-    gnu_property! if type == :gnu
-  end
-
-  def set!(nsize: nil, dsize: nil, type: nil, name: nil, desc: nil)
-    @nsize = num2bytes(nsize, 4) if check(nsize, 4)
-    @dsize = num2bytes(dsize, 4) if check(dsize, 4)
-    @type = num2bytes(type, 4) if check(type, 4)
-    @name = name!(name) if name
-    @desc = desc!(desc) if desc
-    self
-  end
-
-  def gnu_property! = set!(nsize: 0x04, dsize: 0x20, type: 0x05, name: "GNU", desc: %w(02 00 01 c0 04 00 00 00 00 00 00 00 00 00 00 00 01 00 01 c0 04 00 00 00 01 00 00 00 00 00 00 00).map { |val| val.to_i(16) })
-  def null! = set!(nsize: 0, dsize: 0, type: 0, name: "NULL", desc: [0])
-
-  private
-
-  def name!(name) = align(@name = name.bytes, 4)
-  def desc!(desc) = align(@desc = desc.is_a?(Array) ? desc : desc.bytes, 4)
-  def bytes = [@nsize, @dsize, @type, @name, @desc]
-end
diff --git a/lib/caotral/assembler/elf/section/null.rb b/lib/caotral/assembler/elf/section/null.rb
deleted file mode 100644
index e5dcb37..0000000
--- a/lib/caotral/assembler/elf/section/null.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-class Caotral::Assembler::ELF::Section::Null
-  include Caotral::Assembler::ELF::Utils
-  def initialize(**opts) = nil
-  def build = bytes.flatten.pack("C*")
-  def set! = self
-  private def bytes = []
-end
diff --git a/lib/caotral/assembler/elf/section/shstrtab.rb b/lib/caotral/assembler/elf/section/shstrtab.rb
deleted file mode 100644
index 493a6d0..0000000
--- a/lib/caotral/assembler/elf/section/shstrtab.rb
+++ /dev/null
@@ -1,22 +0,0 @@
-class Caotral::Assembler::ELF::Section::Shstrtab
-  include Caotral::Assembler::ELF::Utils
-  def initialize(**opts) = @name = []
-  def build = bytes.flatten.pack("C*")
-  def set!(name:) = (@name << name!(name); self)
-
-  private
-  def bytes = [@name, [0]]
-  def name!(name)
-    case name
-    when String
-      (name.match(/\A\0\..+\z/) ? name : "\0.#{name}").bytes
-    when Array
-      raise Caotral::Assembler::ELF::Error, "unaccepted type in Array" unless name.all? { |elem| elem.is_a?(Integer) }
-      n = name
-      n.unshift(0) && n.push(0) unless n.first == 0 && n.last == 0
-      n
-    else
-      raise Caotral::Assembler::ELF::Error, "unsupported type"
-    end
-  end
-end
diff --git a/lib/caotral/assembler/elf/section/strtab.rb b/lib/caotral/assembler/elf/section/strtab.rb
deleted file mode 100644
index 8984894..0000000
--- a/lib/caotral/assembler/elf/section/strtab.rb
+++ /dev/null
@@ -1,5 +0,0 @@
-class Caotral::Assembler::ELF::Section::Strtab
-  include Caotral::Assembler::ELF::Utils
-  def initialize(names = "\0main\0", **opts) = @names = names
-  def build = @names.bytes.pack("C*")
-end
diff --git a/lib/caotral/assembler/elf/section/symtab.rb b/lib/caotral/assembler/elf/section/symtab.rb
deleted file mode 100644
index 215e8cc..0000000
--- a/lib/caotral/assembler/elf/section/symtab.rb
+++ /dev/null
@@ -1,37 +0,0 @@
-class Caotral::Assembler::ELF::Section::Symtab
-  include Caotral::Assembler::ELF::Utils
-  def initialize(**opts)
-    @entsize = []
-    @name = num2bytes(0, 4)
-    @info = num2bytes(0, 1)
-    @other = num2bytes(0, 1)
-    @shndx = num2bytes(0, 2)
-    @value = num2bytes(0, 8)
-    @size = num2bytes(0, 8)
-  end
-
-  def set!(entsize: nil, name: nil, info: nil, other: nil, shndx: nil, value: nil, size: nil)
-    @entsize = [0] * entsize unless entsize.nil?
-    @name = name2bytes(name, 4) if check(name, 4)
-    @info = num2bytes(info, 1) if check(info, 1)
-    @other = num2bytes(other, 1) if check(other, 1)
-    @shndx = num2bytes(shndx, 2) if check(shndx, 2)
-    @value = num2bytes(value, 8) if check(value, 8)
-    @size = num2bytes(size, 8) if check(size, 8)
-  end
-
-  private
-  def bytes = [@entsize, @name, @info, @other, @shndx, @value, @size]
-  def name2bytes(name, bytes)
-    case name
-    when String
-      name.bytes.reverse
-    when Array
-      name[0..bytes]
-    when Integer
-      num2bytes(name, bytes)
-    else
-      [0] * bytes
-    end
-  end
-end
diff --git a/lib/caotral/assembler/elf/section/text.rb b/lib/caotral/assembler/elf/section/text.rb
deleted file mode 100644
index c82b012..0000000
--- a/lib/caotral/assembler/elf/section/text.rb
+++ /dev/null
@@ -1,265 +0,0 @@
-class Caotral::Assembler::ELF::Section::Text
-  PREFIX = {
-    REX_W: 0x48,
-  }.freeze
-
-  REGISTER_CODE = {
-    RAX: 0b000,
-    RCX: 0b001,
-    RDX: 0b010,
-    RBX: 0b011,
-    RSP: 0b100,
-    RBP: 0b101,
-    RSI: 0b110,
-    RDI: 0b111,
-  }.freeze
-
-  OPECODE = {
-    ADD:  [0x01],
-    CMP:  [0x39],
-    CQO:  [0x99],
-    IDIV: [0xf7],
-    IMUL: [0x0f],
-    MOV:  [0x89],
-    MOVR: [0x8B],
-    MOVXZ: [0x0f, 0xb7],
-    SUB: [0x83],
-    XOR: [0x31],
-  }.freeze
-  HEX_PATTERN = /\A0x[0-9a-fA-F]+\z/.freeze
-
-  def initialize(**opts)
-    @bytes = []
-    @entries = []
-    @label_positions = {}
-  end
-
-  def assemble!(line)
-    line = line.strip
-    return if line.empty?
-    @entries << parse_line(line)
-  end
-
-  def build
-    @label_positions.clear
-    offset = 0
-    @entries.each do |entry|
-      if entry[:label]
-        @label_positions[entry[:label]] = offset
-        next
-      end
-      offset += entry[:size]
-    end
-
-    @bytes = []
-    offset = 0
-    @entries.each do |entry|
-      next if entry[:label]
-      bytes = encode(entry, offset)
-      @bytes << bytes
-      offset += bytes.size
-    end
-
-    @bytes.flatten.pack("C*")
-  end
-
-  def size = build.bytesize
-  def align(val, bytes) = (val << [0] until build.bytesize % bytes == 0)
-
-  private
-
-  def encode(entry, offset)
-    opecode(entry[:op], offset, *entry[:operands])
-  end
-
-  def parse_line(line)
-    return { label: line.delete_suffix(":"), size: 0 } if line.end_with?(":")
-    op, *operands = line.split(/\s+/).reject(&:empty?).map { it.gsub(/,/, "") }
-    size = instruction_size(op, *operands)
-    { op:, operands:, size: }
-  end
-
-  def instruction_size(op, *operands)
-    case op
-    when "je", "jne"
-      6
-    when "jmp"
-      5
-    else
-      opecode(op, 0, *operands).size
-    end
-  end
-
-  def opecode(op, offset, *operands)
-    case op
-    when "push"
-      push(*operands)
-    when "mov", "movzb"
-      [PREFIX[:REX_W], *mov(op, *operands)]
-    when "sub", "add", "imul", "cqo", "idiv"
-      [PREFIX[:REX_W], *calc(op, *operands)]
-    when "xor"
-      [PREFIX[:REX_W], *calc_bit(op, *operands)]
-    when "lea"
-      [PREFIX[:REX_W], *calc_addr(op, *operands)]
-    when "pop"
-      pop(*operands)
-    when "cmp"
-      [PREFIX[:REX_W], *cmp(op, *operands)]
-    when "sete", "setl"
-      sete(op, *operands)
-    when "je", "jmp", "jne"
-      jump(op, offset, *operands)
-    when "syscall"
-      [0x0f, 0x05]
-    when "ret"
-      [0xc3]
-    else
-      raise Caotral::Assembler::ELF::Error, "yet implemented operations: #{op}"
-    end
-  end
-
-  def jump(op, offset, *operands)
-    label = operands.first
-    target = @label_positions.fetch(label) do
-      raise Caotral::Compiler::Assembler::ELF::Error, "unknown label: #{label}"
-    end
-    size = instruction_size(op, label)
-    rel = target - (offset + size)
-    displacement = [rel].pack("l<").unpack("C*")
-    case op
-    when "je"
-      [0x0f, 0x84, *displacement]
-    when "jmp"
-      [0xe9, *displacement]
-    when "jne"
-      [0x0f, 0x85, *displacement]
-    end
-  end
-
-  def mov(op, *operands)
-    reg = case operands
-          in ["rax", "rbp"]
-            [0xe8]
-          in ["rbp", "rsp"]
-            [0xe5]
-          in ["rsp", "rbp"]
-            [0xec]
-          in ["[rax]", "rdi"]
-            [0x38]
-          in ["rax", "al"]
-            op = "MOVXZ"
-            [0xc0]
-          in ["rax", "[rax]"]
-            op = "MOVR"
-            [0x00]
-          in ["rdi", "rax"]
-            [0xC7]
-          in ["rax", HEX_PATTERN]
-            return [0xC7, 0xC0, *immediate(operands[1])]
-          else
-            operands&.map { reg(_1) }
-          end # steep:ignore
-    [OPECODE[op.upcase.to_sym], reg].flatten
-  end
-
-  def calc(op, *operands)
-    ope_code = OPECODE[op.upcase.to_sym]
-    case [op, *operands]
-    in ["sub", "rax", "rdi"]
-      [0x29, 0xf8]
-    in ["add", "rax", "rdi"]
-      [ope_code, 0xf8]
-    in ["imul", "rax", "rdi"]
-      [ope_code, 0xaf, 0xc7]
-    in ["idiv", "rdi"]
-      [ope_code, 0xff]
-    in ["sub", "rsp", *num]
-      [ope_code, 0xec, *num.map { |n| n.to_i(16) }]
-    in ["sub", "rax", *num]
-      [ope_code, 0xe8, *num.map { |n| n.to_i(16) }]
-    in ["cqo"]
-      [0x99]
-    end # steep:ignore
-  end
-
-  def calc_bit(op, *operands)
-    case [op, *operands]
-    in ["xor", "rax", "rax"]
-      [0x31, 0xc0]
-    in ["xor", "rdi", "rdi"]
-      [0x31, 0xff]
-    end # steep:ignore
-  end
-
-  def calc_addr(op, *operands)
-    case [op, *operands]
-    in ["lea", "rax", *addrs]
-      rm, disp = parse_addressing_mode(addrs.first)
-      [0x8D, *mod_rm(0b01, 0b000, rm), disp]
-    end # steep:ignore
-  end
-
-  def cmp(op, *operands)
-    case operands
-    in ["rax", "rdi"]
-      [0x39, 0xf8]
-    in ["rax", "0"]
-      [0x83, 0xf8, 0x00]
-    end # steep:ignore
-  end
-
-  def sete(op, *operands)
-    case [op, operands]
-    in ["sete", ["al"]]
-      [0x0f, 0x94, 0xc0]
-    in ["setl", ["al"]]
-      [0x0f, 0x9c, 0xc0]
-    end # steep:ignore
-  end
-
-  def push(*operands)
-    case operands
-    in ["rbp"] | ["rdi"]
-      [0x55]
-    in ["rax"]
-      [0x50]
-    in [HEX_PATTERN]
-       [0x68, *immediate(operands.first)]
-    else
-      [0x6a, *operands.map { |o| reg(o) }]
-    end # steep:ignore
-  end
-
-  def pop(*operands)
-    case operands
-    in ["rax"] | ["rdi"]
-      [0x58 + REGISTER_CODE[operands.first.upcase.to_sym]]
-    in ["rbp"]
-      [0x5d]
-    end # steep:ignore
-  end
-
-  def reg(r)
-    case r
-    when "rsp"
-      0xec
-    when "rbp"
-      0x5e
-    when "rax"
-      0x29
-    when "rdi"
-      0xf8
-    when /\d+/
-      r.to_i(16)
-    else
-      raise Caotral::Assembler::ELF::Error, "yet implemented operand address: #{r}"
-    end
-  end
-  def immediate(operand) = [operand.to_i(16)].pack("L").unpack("C*")
-  def mod_rm(mod, reg, rm) = (mod << 6) | (reg << 3) | rm
-  def parse_addressing_mode(str)
-    m = str.match(/\[(?<reg>\w+)(?<disp>[\+\-]\d+)?\]/)
-    [REGISTER_CODE[m[:reg].upcase.to_sym], m[:disp].to_i & 0xff]
-  end
-end
diff --git a/lib/caotral/assembler/elf/section_header.rb b/lib/caotral/assembler/elf/section_header.rb
deleted file mode 100644
index a0a9e34..0000000
--- a/lib/caotral/assembler/elf/section_header.rb
+++ /dev/null
@@ -1,44 +0,0 @@
-class Caotral::Assembler::ELF::SectionHeader
-  include Caotral::Assembler::ELF::Utils
-  def initialize
-    @name = nil
-    @type = nil
-    @flags = nil
-    @addr = nil
-    @offset = nil
-    @size = nil
-    @link = nil
-    @info = nil
-    @addralign = nil
-    @entsize = nil
-  end
-
-  def build = bytes.flatten.pack("C*")
-
-  def set!(name: nil, type: nil, flags: nil, addr: nil,
-           offset: nil, size: nil, link: nil, info: nil,
-           addralign: nil, entsize: nil)
-    @name = num2bytes(name, 4) if check(name, 4)
-    @type = num2bytes(type, 4) if check(type, 4)
-    @flags = num2bytes(flags, 8)  if check(flags, 8)
-    @addr = num2bytes(addr, 8) if check(addr, 8)
-    @offset = num2bytes(offset, 8) if check(offset, 8)
-    @size = num2bytes(size, 8) if check(size, 8)
-    @link = num2bytes(link, 4) if check(link, 4)
-    @info = num2bytes(info, 4) if check(info, 4)
-    @addralign = num2bytes(addralign, 8) if check(addralign, 8)
-    @entsize = num2bytes(entsize, 8) if check(entsize, 8)
-    self
-  end
-
-  def null! = set!(name: 0, type: 0, flags: 0, addr: 0, offset: 0, size: 0, link: 0, info: 0, addralign: 0, entsize: 0)
-  def text! = set!(flags: 0x06, addralign: 0x01, addr: 0, type: 1, entsize: 0, link: 0, info: 0)
-  def data! = set!(type: 0x01, flags: 0x03, addralign: 1, addr: 0, info: 0, link: 0, entsize: 0)
-  def bss! = set!(type: 0x8, flags: 3, addralign: 1, addr: 0, info: 0, link: 0, entsize: 0)
-  def note! = set!(type: 0x07, flags: 0x02, size: 0x30, addralign: 0x08, addr: 0, link: 0, info: 0, entsize: 0)
-  def symtab! = set!(type: 2, info: 1, addr: 0, link: 6, entsize: 0x18, addralign: 8, flags: 0)
-  def strtab! = set!(type: 3, info: 0, addr: 0, link: 0, entsize: 0, addralign: 1, flags: 0)
-  def shstrtab! = set!(type: 3, info: 0, addr: 0, link: 0, entsize: 0, addralign: 1, flags: 0)
-
-  private def bytes = [@name, @type, @flags, @addr, @offset, @size, @link, @info, @addralign, @entsize]
-end
diff --git a/lib/caotral/assembler/elf/sections.rb b/lib/caotral/assembler/elf/sections.rb
deleted file mode 100644
index 5a99773..0000000
--- a/lib/caotral/assembler/elf/sections.rb
+++ /dev/null
@@ -1,19 +0,0 @@
-require_relative "section"
-
-class Caotral::Assembler::ELF::Sections
-  ATTRIBUTES = %i|null text data bss note symtab strtab shstrtab|
-  attr_reader *ATTRIBUTES
-
-  def initialize
-    @null = Caotral::Assembler::ELF::Section.new(type: :null)
-    @text = Caotral::Assembler::ELF::Section.new(type: :text)
-    @data = Caotral::Assembler::ELF::Section.new(type: :data)
-    @bss = Caotral::Assembler::ELF::Section.new(type: :bss)
-    @note = Caotral::Assembler::ELF::Section.new(type: :note, options: {type: :gnu})
-    @symtab = Caotral::Assembler::ELF::Section.new(type: :symtab)
-    @strtab = Caotral::Assembler::ELF::Section.new(type: :strtab)
-    @shstrtab = Caotral::Assembler::ELF::Section.new(type: :shstrtab)
-  end
-
-  def each(&block) = ATTRIBUTES.each { |t|  yield send(t) }
-end
diff --git a/lib/caotral/assembler/elf/utils.rb b/lib/caotral/assembler/elf/utils.rb
deleted file mode 100644
index e10f46b..0000000
--- a/lib/caotral/assembler/elf/utils.rb
+++ /dev/null
@@ -1,23 +0,0 @@
-module Caotral::Assembler::ELF::Utils
-  def build = (build_errors; bytes.flatten.pack("C*"))
-  def size = build.bytesize
-  def set! = (raise Caotral::Assembler::ELF::Error, "should be implementing #{self.class}")
-  def empties = must_be_filled_section_fields
-
-  private
-  def align(val, bytes)
-    val << 0 until val.size % bytes == 0
-    val
-  end
-  def bytes = (raise Caotral::Assembler::ELF::Error, "should be implementing #{self.class}")
-  def must_be_filled_section_fields = instance_variables.reject { |i| instance_variable_get(i) }
-  def num2bytes(val, bytes) = hexas(val, bytes).reverse
-  def check(val, bytes) = ((val.is_a?(Array) && val.all? { |v| v.is_a?(Integer) } && val.size == bytes) || (val.is_a?(Integer) && (hexas(val, bytes).size == bytes)))
-  def hexas(val, hex) = ("%0#{hex*2}x" % val).scan(/.{1,2}/).map { |v| v.to_i(16) }.then { |list| list.unshift(0) until list.size >= hex; list }
-  def build_errors
-    return unless bytes.any?(&:nil?)
-    errors = []
-    bytes.each_with_index { |v, idx| errors << instance_variables[idx] if v.nil? }
-    raise Caotral::Assembler::ELF::Error, "unaccepted types: #{errors.join(",")}"
-  end
-end
diff --git a/lib/caotral/assembler/reader.rb b/lib/caotral/assembler/reader.rb
new file mode 100644
index 0000000..89a7a6c
--- /dev/null
+++ b/lib/caotral/assembler/reader.rb
@@ -0,0 +1,29 @@
+require "caotral/binary/elf"
+
+module Caotral
+  class Assembler
+    class Reader
+      attr_reader :instructions
+      def initialize(input:, debug: false)
+        @input, @debug = input, debug
+        @instructions = Hash.new { |h, k| h[k] = [] }
+      end
+
+      def read
+        File.open(@input, "r") do |reader|
+          current_label = nil
+          reader.each_line do |line|
+            if /^(?<label>[_A-Za-z.]\w*):/ =~ line
+              current_label = label
+              next
+            end
+            next if current_label.nil?
+
+            @instructions[current_label] << line
+          end
+        end
+        @instructions
+      end
+    end
+  end
+end
diff --git a/lib/caotral/assembler/writer.rb b/lib/caotral/assembler/writer.rb
new file mode 100644
index 0000000..58ea221
--- /dev/null
+++ b/lib/caotral/assembler/writer.rb
@@ -0,0 +1,90 @@
+require "caotral/binary/elf"
+
+module Caotral
+  class Assembler
+    class Writer
+      def self.write!(elf_obj:, output:, debug: false) = new(elf_obj:, output:, debug:).write
+      def initialize(elf_obj:, output:, debug: false)
+        @elf_obj = elf_obj
+        @output = output
+        @debug = debug
+      end
+
+      def write(output: @output)
+        File.open(output, "wb") do |f|
+          f.write(@elf_obj.header.build)
+          shstrtab_names = String.new
+          offsets = {}
+          @elf_obj.sections.each do |section|
+            section_name = section.section_name.to_s
+            shstrtab_names << "\0#{section_name}"
+            next if section.section_name == ".shstrtab"
+            offsets[section_name] = f.pos
+            case section.body
+            in String
+              f.write(section.body)
+            in Array
+              section.body.each { |s| f.write(s.build) }
+            else
+              next if section.body.nil?
+              f.write(section.body.build)
+            end
+          end
+          shstrtab = @elf_obj.find_by_name(".shstrtab")
+          shstrtab.body.names = shstrtab_names << "\0".b
+          offsets[".shstrtab"] = f.pos
+          f.write(shstrtab.body.build)
+          shoffset = f.pos
+          shnum = @elf_obj.sections.size
+          shstrndx = shnum - 1
+          offset = 0
+          symtab = @elf_obj.find_by_name(".symtab")
+          symtab.header.set!(entsize: 24)
+          @elf_obj.sections.each do |section|
+            header = section.header
+            section_name = section.section_name.to_s
+            name = section_name.empty? ? 0 : shstrtab.body.offset_of(section_name)
+            body = section.body
+            size = case body
+                   in String
+                     body.size
+                   in Array
+                     body.map(&:build).map(&:size).sum
+                   in NilClass
+                     0
+                   else
+                     body.build.size
+                   end
+            offset = section.section_name.nil? ? 0 : offsets[section_name]
+            type = decide_type(section)
+            if ".symtab" == section.section_name
+              link = @elf_obj.index(".strtab")
+              info = 1
+              header.set!(name:, offset:, size:, type:, info:, link:)
+            else
+              header.set!(name:, offset:, size:, type:)
+            end
+            f.write(header.build)
+          end
+          @elf_obj.header.set!(shoffset:, shnum:, shstrndx:)
+          f.seek(0)
+          f.write(@elf_obj.header.build)
+        end
+        output
+      end
+
+      private def decide_type(section)
+        case section.section_name
+        when ".text"
+          1
+        when ".symtab"
+          2
+        when ".shstrtab", ".strtab"
+          3
+        else
+          0
+        end
+      end
+    end
+  end
+end
diff --git a/lib/caotral/binary.rb b/lib/caotral/binary.rb
new file mode 100644
index 0000000..b2a4d20
--- /dev/null
+++ b/lib/caotral/binary.rb
@@ -0,0 +1,4 @@
+module Caotral
+  class Binary
+  end
+end
diff --git a/lib/caotral/binary/elf.rb b/lib/caotral/binary/elf.rb
new file mode 100644
index 0000000..8a652b2
--- /dev/null
+++ b/lib/caotral/binary/elf.rb
@@ -0,0 +1,29 @@
+require_relative "elf/utils"
+require_relative "elf/error"
+require_relative "elf/header"
+require_relative "elf/program_header"
+require_relative "elf/section"
+require_relative "elf/section/rel"
+require_relative "elf/section/strtab"
+require_relative "elf/section/symtab"
+require_relative "elf/section_header"
+require_relative "elf/reader"
+
+module Caotral
+  module Binary
+    class ELF
+      include Enumerable
+      attr_reader :sections
+      attr_accessor :header
+      def initialize
+        @sections = []
+        @header = nil
+      end
+      def each(&block) = @sections.each(&block)
+      def [](idx) = @sections[idx]
+      def find_by_name(section_name) = @sections.find { section_name == it.section_name }
+      def select_by_name(section_name) = @sections.select { section_name == it.section_name }
+      def index(section_name) = @sections.index { section_name == it.section_name }
+    end
+  end
+end
diff --git a/lib/caotral/binary/elf/error.rb b/lib/caotral/binary/elf/error.rb
new file mode 100644
index 0000000..e1c44e5
--- /dev/null
+++ b/lib/caotral/binary/elf/error.rb
@@ -0,0 +1,8 @@
+module Caotral
+  module Binary
+    class ELF
+      class Error < StandardError
+      end
+    end
+  end
+end
diff --git a/lib/caotral/linker/elf/header.rb b/lib/caotral/binary/elf/header.rb
similarity index 69%
rename from lib/caotral/linker/elf/header.rb
rename to lib/caotral/binary/elf/header.rb
index 5533506..bdd32cb 100644
--- a/lib/caotral/linker/elf/header.rb
+++ b/lib/caotral/binary/elf/header.rb
@@ -1,9 +1,9 @@
+require_relative "utils"
 module Caotral
-  class Linker
+  module Binary
     class ELF
       class Header
-        include Caotral::Assembler::ELF::Utils
-        attr_reader :entry, :phoffset, :shoffset, :shnum, :shstrndx
+        include Caotral::Binary::ELF::Utils
         IDENT = [0x7f, 0x45, 0x4c, 0x46, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00].freeze
         IDENT_STR = IDENT.pack("C*").freeze
         ELF_FILE_TYPE = { NONE: 0, REL: 1, EXEC: 2, DYN: 3, CORE: 4 }.freeze
@@ -40,18 +40,14 @@ def set!(type: nil, entry: nil, phoffset: nil, shoffset: nil, shnum: nil, shstrn
           self
         end
 
-        def ehsize = get(:ehsize)
-        def phsize = get(:phsize)
-        def phnum = get(:phnum)
-        def shentsize = get(:shentsize)
-        def shnum = get(:shnum)
-        def shstrndx = get(:shstrndx)
-
-        LONG_TYPES = %w[entry phoffset shoffset].freeze
-        INT_TYPES = %w[type version].freeze
-        SHORT_TYPES = %w[ehsize phsize phnum shentsize shnum shstrndx].freeze
-        CHAR_TYPES = %w[arch flags].freeze
-        private_constant :LONG_TYPES, :INT_TYPES, :SHORT_TYPES, :CHAR_TYPES
+        def entry = @entry.pack("C*").unpack1("Q<")
+        def ehsize = @ehsize.pack("C*").unpack1("S<")
+        def phsize = @phsize.pack("C*").unpack1("S<")
+        def phnum = @phnum.pack("C*").unpack1("S<")
+        def shentsize = @shentsize.pack("C*").unpack1("S<")
+        def shnum = @shnum.pack("C*").unpack1("S<")
+        def shstrndx = @shstrndx.pack("C*").unpack1("S<")
+        def shoffset = @shoffset.pack("C*").unpack1("Q<")
 
         private
         def bytes = [
@@ -79,18 +75,6 @@ def elf(type)
             :NONE
           end
         end
-
-        def get(type)
-          val = instance_variable_get(:"@#{type.to_s}").pack("C*")
-          case type.to_s.downcase
-          when *LONG_TYPES; val.unpack("Q<")
-          when *INT_TYPES; val.unpack("L<")
-          when *SHORT_TYPES; val.unpack("S<")
-          when *CHAR_TYPES; val.unpack("C<")
-          else
-            raise "not specified: #{type}"
-          end.first
-        end
       end
     end
   end
diff --git a/lib/caotral/linker/elf/program_header.rb b/lib/caotral/binary/elf/program_header.rb
similarity index 92%
rename from lib/caotral/linker/elf/program_header.rb
rename to lib/caotral/binary/elf/program_header.rb
index a5177ec..9eaaf68 100644
--- a/lib/caotral/linker/elf/program_header.rb
+++ b/lib/caotral/binary/elf/program_header.rb
@@ -1,8 +1,10 @@
+require "caotral/binary/elf/utils"
+
 module Caotral
-  class Linker
+  module Binary
     class ELF
       class ProgramHeader
-        include Caotral::Assembler::ELF::Utils
+        include Caotral::Binary::ELF::Utils
         def initialize
           @type = num2bytes(0, 4)
           @flags = num2bytes(0, 4)
diff --git a/lib/caotral/binary/elf/reader.rb b/lib/caotral/binary/elf/reader.rb
new file mode 100644
index 0000000..2f6d590
--- /dev/null
+++ b/lib/caotral/binary/elf/reader.rb
@@ -0,0 +1,127 @@
+require "stringio"
+
+module Caotral
+  module Binary
+    class ELF
+      class Reader
+        attr_reader :context
+        def self.read!(input:, debug: false, linker_options: []) = new(input:, debug:, linker_options:).read
+
+        def initialize(input:, debug: false, linker_options: [])
+          @input = decision(input)
+          @bin = StringIO.new(@input.read)
+          @context = Caotral::Binary::ELF.new
+          @context.header = Caotral::Binary::ELF::Header.new
+        end
+
+        def read
+          header = @bin.read(0x40)
+          ident = header[0, 16]
+          raise "Not ELF file" unless ident == Caotral::Binary::ELF::Header::IDENT_STR
+    
+          entry = header[24, 8].unpack("Q<").first
+          phoffset = header[32, 8].unpack("Q<").first
+          shoffset = header[40, 8].unpack("Q<").first
+          shentsize = header[58, 2].unpack("S<").first
+          shnum = header[60, 2].unpack("S<").first
+          shstrndx = header[62, 2].unpack("S<").first
+          @context.header.set!(entry:, phoffset:, shoffset:, shnum:, shstrndx:)
+
+          @bin.pos = shoffset
+          shnum.times do |i|
+            sh_entry = @bin.read(shentsize)
+            name = sh_entry[0, 4].unpack("L<").first
+            type_val = sh_entry[4, 4].unpack("L<").first
+            flags = sh_entry[8, 8].unpack("Q<").first
+            addr = sh_entry[16, 8].unpack("Q<").first
+            offset = sh_entry[24, 8].unpack("Q<").first
+            size = sh_entry[32, 8].unpack("Q<").first
+            link = sh_entry[40, 4].unpack("L<").first
+            info = sh_entry[44, 4].unpack("L<").first
+            addralign = sh_entry[48, 8].unpack("Q<").first
+            entsize = sh_entry[56, 8].unpack("Q<").first
+            type_sym = type(type_val)
+            section_header = Caotral::Binary::ELF::SectionHeader.new
+            section_header.set!(name:, type: type_val, flags:, addr:, offset:, size:, link:, info:, addralign:, entsize:)
+            section_name = i == shstrndx ? ".shstrtab" : nil
+            section = Caotral::Binary::ELF::Section.new(header: section_header, section_name:, body: nil)
+            @context.sections.push(section)
+          end
+
+          shstrtab = @context.sections[shstrndx].tap do |shstrtab|
+            @bin.pos = shstrtab.header.offset
+            names = @bin.read(shstrtab.header.size)
+            shstrtab.body = Caotral::Binary::ELF::Section::Strtab.new(names)
+            shstrtab
+          end
+
+          names = shstrtab.body.names
+
+          @context.sections.each_with_index do |section, i|
+            next if i == shstrndx || section.header.name == 0
+            offset = section.header.name
+            section.section_name = names.byteslice(offset..).split("\0", 2).first
+            type = section.header.type
+            @bin.pos = section.header.offset
+            body_bin = @bin.read(section.header.size)
+            section.body = case type
+                           when :strtab
+                             Caotral::Binary::ELF::Section::Strtab.new(body_bin)
+                           when :symtab
+                             symtab_entsize = section.header.entsize
+                             count = body_bin.bytesize / symtab_entsize
+                             count.times.map do |i|
+                               sym_bin = body_bin[i * symtab_entsize, symtab_entsize]
+                               name = sym_bin[0, 4].unpack1("L<")
+                               info = sym_bin[4, 1].unpack1("C")
+                               other = sym_bin[5, 1].unpack1("C")
+                               shndx = sym_bin[6, 2].unpack1("S<")
+                               value = sym_bin[8, 8].unpack1("Q<")
+                               size = sym_bin[16, 8].unpack1("Q<")
+                               Caotral::Binary::ELF::Section::Symtab.new.set!(name:, info:, other:, shndx:, value:, size:)
+                             end
+                           when :rel, :rela
+                             rela = type == :rela
+                             rel_entsize = section.header.entsize
+                             rel_entsize = rela ? 24 : 16 if rel_entsize == 0
+                             count = body_bin.bytesize / rel_entsize
+                             count.times.map do |i|
+                               rel_bin = body_bin.byteslice(i * rel_entsize, rel_entsize)
+                               offset = rel_bin[0, 8].unpack1("Q<")
+                               info = rel_bin[8, 8].unpack1("Q<")
+                               addend = rela ? rel_bin[16, 8].unpack1("q<") : nil
+                               Caotral::Binary::ELF::Section::Rel.new(addend: rela).set!(offset:, info:, addend:)
+                             end
+                           when :progbits
+                             body_bin
+                           end
+          end
+
+          strtab = @context.find_by_name(".strtab")
+          @context.sections.select { it.header.type == :symtab }.each do |symtab|
+            symtab.body.each do |sym|
+              name_offset = sym.name_offset
+              sym.name_string = strtab.body.lookup(name_offset)
+            end
+          end
+
+          @context
+        ensure
+          @input.close
+        end
+
+        private
+        def decision(input)
+          case input
+          when String, Pathname
+            File.open(File.expand_path(input.to_s), "rb")
+          else
+            raise ArgumentError, "wrong input type"
+          end
+        end
+
+        def type(num) = Caotral::Binary::ELF::SectionHeader::SHT_BY_VALUE.fetch(num, :unknown)
+      end
+    end
+  end
+end
diff --git a/lib/caotral/binary/elf/section.rb b/lib/caotral/binary/elf/section.rb
new file mode 100644
index 0000000..57e9d3b
--- /dev/null
+++ b/lib/caotral/binary/elf/section.rb
@@ -0,0 +1,15 @@
+module Caotral
+  module Binary
+    class ELF
+      class Section
+        attr_accessor :body, :section_name
+        attr_reader :header
+        def initialize(header:, body:, section_name:)
+          @header = header
+          @body = body
+          @section_name = section_name
+        end
+      end
+    end
+  end
+end
diff --git a/lib/caotral/linker/elf/section/rel.rb b/lib/caotral/binary/elf/section/rel.rb
similarity index 91%
rename from lib/caotral/linker/elf/section/rel.rb
rename to lib/caotral/binary/elf/section/rel.rb
index b6ecf62..4c0f520 100644
--- a/lib/caotral/linker/elf/section/rel.rb
+++ b/lib/caotral/binary/elf/section/rel.rb
@@ -1,9 +1,10 @@
+require "caotral/binary/elf/utils"
 module Caotral
-  class Linker
+  module Binary
     class ELF
       class Section
         class Rel
-          include Caotral::Assembler::ELF::Utils
+          include Caotral::Binary::ELF::Utils
           def initialize(addend: true)
             @offset = num2bytes(0, 8)
             @info = num2bytes(0, 8)
diff --git a/lib/caotral/linker/elf/section/strtab.rb b/lib/caotral/binary/elf/section/strtab.rb
similarity index 82%
rename from lib/caotral/linker/elf/section/strtab.rb
rename to lib/caotral/binary/elf/section/strtab.rb
index 310e35a..7d71c1a 100644
--- a/lib/caotral/linker/elf/section/strtab.rb
+++ b/lib/caotral/binary/elf/section/strtab.rb
@@ -1,10 +1,11 @@
+require "caotral/binary/elf/utils"
 module Caotral
-  class Linker
+  module Binary
     class ELF
       class Section
         class Strtab
-          include Caotral::Assembler::ELF::Utils
-          attr_reader :names
+          include Caotral::Binary::ELF::Utils
+          attr_accessor :names
           def initialize(names = "\0main\0", **opts) = @names = names
           def build = @names.bytes.pack("C*")
           def offset_of(name)
diff --git a/lib/caotral/linker/elf/section/symtab.rb b/lib/caotral/binary/elf/section/symtab.rb
similarity index 82%
rename from lib/caotral/linker/elf/section/symtab.rb
rename to lib/caotral/binary/elf/section/symtab.rb
index a331418..f3882ce 100644
--- a/lib/caotral/linker/elf/section/symtab.rb
+++ b/lib/caotral/binary/elf/section/symtab.rb
@@ -1,9 +1,11 @@
+require "caotral/binary/elf/utils"
+
 module Caotral
-  class Linker
+  module Binary
     class ELF
       class Section
         class Symtab
-          include Caotral::Assembler::ELF::Utils
+          include Caotral::Binary::ELF::Utils
           attr_accessor :name_string
           def initialize(**opts)
             @entsize = []
@@ -15,6 +17,7 @@ def initialize(**opts)
             @size = num2bytes(0, 8)
             @name_string = ""
           end
+          def build = bytes.flatten.pack("C*")
 
           def set!(name: nil, info: nil, other: nil, shndx: nil, value: nil, size: nil)
             @name = num2bytes(name, 4) if check(name, 4)
@@ -28,6 +31,8 @@ def set!(name: nil, info: nil, other: nil, shndx: nil, value: nil, size: nil)
 
           def name_offset = @name.pack("C*").unpack1("L<")
           def value = @value.pack("C*").unpack1("Q<")
+
+          private def bytes = [@name, @info, @other, @shndx, @value, @size]
         end
       end
     end
diff --git a/lib/caotral/binary/elf/section_header.rb b/lib/caotral/binary/elf/section_header.rb
new file mode 100644
index 0000000..3532d12
--- /dev/null
+++ b/lib/caotral/binary/elf/section_header.rb
@@ -0,0 +1,54 @@
+require_relative "utils"
+
+module Caotral
+  module Binary
+    class ELF
+      class SectionHeader
+        include Caotral::Binary::ELF::Utils
+        SHT = { null: 0, progbits: 1, symtab: 2, strtab: 3, rela: 4, hash: 5, dynamic: 6, note: 7, nobits: 8, rel: 9, shlib: 10, dynsym: 11, }.freeze
+        SHT_BY_VALUE = SHT.invert.freeze
+
+        def initialize
+          @name = num2bytes(0, 4)
+          @type = num2bytes(0, 4)
+          @flags = num2bytes(0, 8)
+          @addr = num2bytes(0, 8)
+          @offset = num2bytes(0, 8)
+          @size = num2bytes(0, 8)
+          @link = num2bytes(0, 4)
+          @info = num2bytes(0, 4)
+          @addralign = num2bytes(0, 8)
+          @entsize = num2bytes(0, 8)
+        end
+
+        def build = bytes.flatten.pack("C*")
+
+        def set!(name: nil, type: nil, flags: nil, addr: nil,
+                 offset: nil, size: nil, link: nil, info: nil,
+                 addralign: nil, entsize: nil)
+          @name = num2bytes(name, 4) if check(name, 4)
+          @type = num2bytes(type, 4) if check(type, 4)
+          @flags = num2bytes(flags, 8)  if check(flags, 8)
+          @addr = num2bytes(addr, 8) if check(addr, 8)
+          @offset = num2bytes(offset, 8) if check(offset, 8)
+          @size = num2bytes(size, 8) if check(size, 8)
+          @link = num2bytes(link, 4) if check(link, 4)
+          @info = num2bytes(info, 4) if check(info, 4)
+          @addralign = num2bytes(addralign, 8) if check(addralign, 8)
+          @entsize = num2bytes(entsize, 8) if check(entsize, 8)
+          self
+        end
+
+        def name = @name.pack("C*").unpack1("L<")
+        def offset = @offset.pack("C*").unpack1("Q<")
+        def entsize = @entsize.pack("C*").unpack1("Q<")
+        def size = @size.pack("C*").unpack1("Q<")
+        def type = SHT_BY_VALUE[@type.pack("C*").unpack1("L<")]
+        def info = @info.pack("C*").unpack1("L<")
+        def addr = @addr.pack("C*").unpack1("Q<")
+
+        private def bytes = [@name, @type, @flags, @addr, @offset, @size, @link, @info, @addralign, @entsize]
+      end
+    end
+  end
+end
diff --git a/lib/caotral/binary/elf/utils.rb b/lib/caotral/binary/elf/utils.rb
new file mode 100644
index 0000000..b0ad7e8
--- /dev/null
+++ b/lib/caotral/binary/elf/utils.rb
@@ -0,0 +1,31 @@
+require_relative "error"
+
+module Caotral
+  module Binary
+    class ELF
+      module Utils
+        def build = (build_errors; bytes.flatten.pack("C*"))
+        def size = build.bytesize
+        def set! = (raise Caotral::Binary::ELF::Error, "should be implementing #{self.class}")
+        def empties = must_be_filled_section_fields
+
+        private
+        def align(val, bytes)
+          val << 0 until val.size % bytes == 0
+          val
+        end
+        def bytes = (raise Caotral::Binary::ELF::Error, "should be implementing #{self.class}")
+        def must_be_filled_section_fields = instance_variables.reject { |i| instance_variable_get(i) }
+        def num2bytes(val, bytes) = hexas(val, bytes).reverse
+        def check(val, bytes) = ((val.is_a?(Array) && val.all? { |v| v.is_a?(Integer) } && val.size == bytes) || (val.is_a?(Integer) && (hexas(val, bytes).size == bytes)))
+        def hexas(val, hex) = ("%0#{hex*2}x" % val).scan(/.{1,2}/).map { |v| v.to_i(16) }.then { |list| list.unshift(0) until list.size >= hex; list }
+        def build_errors
+          return unless bytes.any?(&:nil?)
+          errors = []
+          bytes.each_with_index { |v, idx| errors << instance_variables[idx] if v.nil? }
+          raise Caotral::Binary::ELF::Error, "unaccepted types: #{errors.join(",")}"
+        end
+      end
+    end
+  end
+end
diff --git a/lib/caotral/linker.rb b/lib/caotral/linker.rb
index 7521491..8abe92d 100644
--- a/lib/caotral/linker.rb
+++ b/lib/caotral/linker.rb
@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-require_relative "linker/reader"
+require_relative "binary/elf/reader"
 require_relative "linker/writer"
 
 module Caotral
@@ -12,11 +12,14 @@ def initialize(input:, output: "a.out", linker: "mold", linker_options: [], shar
       @debug, @shared = debug, shared
     end
 
-    def link(input: @input, output: @output, debug: @debug, shared: @shared) = IO.popen(link_command).close
+    def link(input: @input, output: @output, debug: @debug, shared: @shared)
+      return to_elf(input:, output:, debug:) if @linker == "self"
+
+      IO.popen(link_command).close
+    end
 
     def link_command(input: @input, output: @output, debug: @debug, shared: @shared)
       ld_path = []
-      return to_elf(input:, output:, debug:) if @linker == "self"
 
       if @shared
         ld_path << "--shared"
@@ -44,7 +47,7 @@ def libpath = @libpath ||= File.dirname(Dir.glob("/usr/lib*/**/crti.o").last)
     def gcc_libpath = @gcc_libpath ||= File.dirname(Dir.glob("/usr/lib/gcc/x86_64-*/*/crtbegin.o").last)
 
     def to_elf(input: @input, output: @output, debug: @debug)
-      elf_obj = Caotral::Linker::Reader.new(input:, debug:).read
+      elf_obj = Caotral::Binary::ELF::Reader.new(input:, debug:).read
       Caotral::Linker::Writer.new(elf_obj:, output:, debug:).write
     end
   end
diff --git a/lib/caotral/linker/elf.rb b/lib/caotral/linker/elf.rb
deleted file mode 100644
index 0635e21..0000000
--- a/lib/caotral/linker/elf.rb
+++ /dev/null
@@ -1,14 +0,0 @@
-require_relative "elf/header"
-require_relative "elf/sections"
-
-module Caotral
-  class Linker
-    class ELF
-      attr_reader :sections, :header
-      def initialize
-        @sections = Caotral::Linker::ELF::Sections.new
-        @header = Caotral::Linker::ELF::Header.new
-      end
-    end
-  end
-end
diff --git a/lib/caotral/linker/elf/section.rb b/lib/caotral/linker/elf/section.rb
deleted file mode 100644
index 35249f7..0000000
--- a/lib/caotral/linker/elf/section.rb
+++ /dev/null
@@ -1,15 +0,0 @@
-class Caotral::Linker
-  class ELF
-    class Section
-      attr_accessor :header, :body, :section_name
-      def initialize(type:, section_name: nil, options: {})
-        type_string = type.to_s.capitalize
-        type_string = type_string.upcase if type_string == "Bss"
-        @section_name = (section_name.nil? ? type_string : section_name).to_s.downcase
-        @header, @body = nil, nil
-      end
-
-      def name = @section_name == "null" ? "" : "\0#{@section_name}"
-    end
-  end
-end
diff --git a/lib/caotral/linker/elf/section/text.rb b/lib/caotral/linker/elf/section/text.rb
deleted file mode 100644
index e3998f5..0000000
--- a/lib/caotral/linker/elf/section/text.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-class Caotral::Linker::ELF::Section::Text
-  def initialize = @bytes = []
-  def build = @bytes.flatten.pack("C*")
-end
diff --git a/lib/caotral/linker/elf/section_header.rb b/lib/caotral/linker/elf/section_header.rb
deleted file mode 100644
index d3fcb04..0000000
--- a/lib/caotral/linker/elf/section_header.rb
+++ /dev/null
@@ -1,78 +0,0 @@
-module Caotral
-  class Linker
-    class ELF
-      class SectionHeader
-        SHT = {
-          null: 0,
-          progbits: 1,
-          symtab: 2,
-          strtab: 3,
-          rela: 4,
-          hash: 5,
-          dynamic: 6,
-          note: 7,
-          nobits: 8,
-          rel: 9,
-          shlib: 10,
-          dynsym: 11,
-        }.freeze
-        SHT_BY_VALUE = SHT.invert.freeze
-        include Caotral::Assembler::ELF::Utils
-        def initialize
-          @name = nil
-          @type = nil
-          @flags = nil
-          @addr = nil
-          @offset = nil
-          @size = nil
-          @link = nil
-          @info = nil
-          @addralign = nil
-          @entsize = nil
-        end
-
-        def build = bytes.flatten.pack("C*")
-
-        def set!(name: nil, type: nil, flags: nil, addr: nil,
-                 offset: nil, size: nil, link: nil, info: nil,
-                 addralign: nil, entsize: nil)
-          @name = num2bytes(name, 4) if check(name, 4)
-          @type = num2bytes(type, 4) if check(type, 4)
-          @flags = num2bytes(flags, 8)  if check(flags, 8)
-          @addr = num2bytes(addr, 8) if check(addr, 8)
-          @offset = num2bytes(offset, 8) if check(offset, 8)
-          @size = num2bytes(size, 8) if check(size, 8)
-          @link = num2bytes(link, 4) if check(link, 4)
-          @info = num2bytes(info, 4) if check(info, 4)
-          @addralign = num2bytes(addralign, 8) if check(addralign, 8)
-          @entsize = num2bytes(entsize, 8) if check(entsize, 8)
-          self
-        end
-
-        def null! = set!(name: 0, type: 0, flags: 0, addr: 0, offset: 0, size: 0, link: 0, info: 0, addralign: 0, entsize: 0)
-        def name = get(:name)
-        def offset = get(:offset)
-        def entsize = get(:entsize)
-        def size = get(:size)
-        def type = SHT_BY_VALUE[@type.pack("C*").unpack("L<").first]
-        def info = get(:info)
-        def addr = get(:addr)
-        LONG_TYPES = %w[flags addr offset size addralign entsize].freeze
-        INT_TYPES = %w[name type link info].freeze
-
-        private_constant :LONG_TYPES, :INT_TYPES
-
-        private def bytes = [@name, @type, @flags, @addr, @offset, @size, @link, @info, @addralign, @entsize]
-        private def get(type)
-          val = instance_variable_get("@#{type.to_s}").pack("C*")
-          case type.to_s
-          when *INT_TYPES; val.unpack("L<")
-          when *LONG_TYPES; val.unpack("Q<")
-          else
-            raise "not specified: #{type}"
-          end.first
-        end
-      end
-    end
-  end
-end
diff --git a/lib/caotral/linker/elf/sections.rb b/lib/caotral/linker/elf/sections.rb
deleted file mode 100644
index ec8444f..0000000
--- a/lib/caotral/linker/elf/sections.rb
+++ /dev/null
@@ -1,37 +0,0 @@
-class Caotral::Linker::ELF::Sections
-  include Enumerable
-
-  def initialize = @sections = []
-  def each(&block) = @sections.each(&block)
-  def add(section) = @sections << section
-  alias << add
-  def size = @sections.size
-  alias length size
-  def empty? = @sections.empty?
-  def count(&block)
-    return @sections.count(&block) if block_given?
-    @sections.size
-  end
-  
-  def [](index)
-    case index
-    when Integer
-      @sections[index]
-    when String, Symbol
-      @sections.find { it.section_name == prepend_dot(index) }
-    else
-      raise ArgumentError, "Invalid index type: #{index.class}"
-    end
-  end
-
-  def index(name)
-    name = prepend_dot(name)
-    @sections.each_with_index do |section, idx|
-      return idx if section.section_name == name
-    end
-  end
-  private def prepend_dot(name)
-    str = name.to_s
-    str.start_with?(".") ? str : ".#{str}"
-  end
-end
diff --git a/lib/caotral/linker/reader.rb b/lib/caotral/linker/reader.rb
deleted file mode 100644
index 1d6c7c1..0000000
--- a/lib/caotral/linker/reader.rb
+++ /dev/null
@@ -1,131 +0,0 @@
-require "stringio"
-require_relative "elf"
-require_relative "elf/section"
-require_relative "elf/section_header"
-require_relative "elf/section/strtab"
-require_relative "elf/section/symtab"
-require_relative "elf/section/rel"
-
-module Caotral
-  class Linker
-    class Reader
-      attr_reader :context
-      def self.read!(input:, debug: false, linker_options: []) = new(input:, debug:, linker_options:).read
-
-      def initialize(input:, debug: false, linker_options: [])
-        @input = decision(input)
-        @bin = StringIO.new(@input.read)
-        @context = Caotral::Linker::ELF.new
-      end
-
-      def read
-        header = @bin.read(0x40)
-        ident = header[0, 16]
-        raise "Not ELF file" unless ident == Caotral::Linker::ELF::Header::IDENT_STR
-    
-        entry = header[24, 8].unpack("Q<").first
-        phoffset = header[32, 8].unpack("Q<").first
-        shoffset = header[40, 8].unpack("Q<").first
-        shentsize = header[58, 2].unpack("S<").first
-        shnum = header[60, 2].unpack("S<").first
-        shstrndx = header[62, 2].unpack("S<").first
-        @context.header.set!(entry:, phoffset:, shoffset:, shnum:, shstrndx:)
-
-        @bin.pos = shoffset
-        shnum.times do |i|
-          sh_entry = @bin.read(shentsize)
-          name = sh_entry[0, 4].unpack("L<").first
-          type_val = sh_entry[4, 4].unpack("L<").first
-          flags = sh_entry[8, 8].unpack("Q<").first
-          addr = sh_entry[16, 8].unpack("Q<").first
-          offset = sh_entry[24, 8].unpack("Q<").first
-          size = sh_entry[32, 8].unpack("Q<").first
-          link = sh_entry[40, 4].unpack("L<").first
-          info = sh_entry[44, 4].unpack("L<").first
-          addralign = sh_entry[48, 8].unpack("Q<").first
-          entsize = sh_entry[56, 8].unpack("Q<").first
-          type_sym = type(type_val)
-          section_header = Caotral::Linker::ELF::SectionHeader.new
-          section_header.set!(name:, type: type_val, flags:, addr:, offset:, size:, link:, info:, addralign:, entsize:)
-          section_name = i == shstrndx ? ".shstrtab" : nil
-          args = { type: type_sym, section_name: }.compact
-          section = Caotral::Linker::ELF::Section.new(**args)
-          section.header = section_header
-          @context.sections.add(section)
-        end
-        shstrtab = @context.sections[shstrndx].tap do |shstrtab|
-          @bin.pos = shstrtab.header.offset
-          names = @bin.read(shstrtab.header.size)
-          shstrtab.body = Caotral::Linker::ELF::Section::Strtab.new(names)
-          shstrtab
-        end
-
-        names = shstrtab.body.names
-
-        @context.sections.each_with_index do |section, i|
-          next if i == shstrndx || section.header.name == 0
-          offset = section.header.name
-          section.section_name = names.byteslice(offset..).split("\0", 2).first
-          type = section.header.type
-          @bin.pos = section.header.offset
-          body_bin = @bin.read(section.header.size)
-          section.body = case type
-                         when :strtab
-                           Caotral::Linker::ELF::Section::Strtab.new(body_bin)
-                         when :symtab
-                           symtab_entsize = section.header.entsize
-                           count = body_bin.bytesize / symtab_entsize
-                           count.times.map do |i|
-                             sym_bin = body_bin[i * symtab_entsize, symtab_entsize]
-                             name = sym_bin[0, 4].unpack1("L<")
-                             info = sym_bin[4, 1].unpack1("C")
-                             other = sym_bin[5, 1].unpack1("C")
-                             shndx = sym_bin[6, 2].unpack1("S<")
-                             value = sym_bin[8, 8].unpack1("Q<")
-                             size = sym_bin[16, 8].unpack1("Q<")
-                             Caotral::Linker::ELF::Section::Symtab.new.set!(name:, info:, other:, shndx:, value:, size:)
-                           end
-                         when :rel, :rela
-                           rela = type == :rela
-                           rel_entsize = section.header.entsize
-                           rel_entsize = rela ? 24 : 16 if rel_entsize == 0
-                           count = body_bin.bytesize / rel_entsize
-                           count.times.map do |i|
-                              rel_bin = body_bin.byteslice(i * rel_entsize, rel_entsize)
-                              offset = rel_bin[0, 8].unpack1("Q<")
-                              info = rel_bin[8, 8].unpack1("Q<")
-                              addend = rela ? rel_bin[16, 8].unpack1("q<") : nil
-                              Caotral::Linker::ELF::Section::Rel.new(addend: rela).set!(offset:, info:, addend:)
-                           end
-                         when :progbits
-                           body_bin
-                         end
-        end
-
-        strtab = @context.sections[".strtab"]
-        @context.sections.select { it.header.type == :symtab }.each do |symtab|
-          symtab.body.each do |sym|
-            name_offset = sym.name_offset
-            sym.name_string = strtab.body.lookup(name_offset)
-          end
-        end
-
-        @context
-      ensure
-        @input.close
-      end
-
-      private
-      def decision(input)
-        case input
-        when String, Pathname
-          File.open(File.expand_path(input.to_s), "rb")
-        else
-          raise ArgumentError, "wrong input type"
-        end
-      end
-
-      def type(num) = Caotral::Linker::ELF::SectionHeader::SHT_BY_VALUE.fetch(num, :unknown)
-    end
-  end
-end
diff --git a/lib/caotral/linker/writer.rb b/lib/caotral/linker/writer.rb
index 8ecddcc..73ec3b3 100644
--- a/lib/caotral/linker/writer.rb
+++ b/lib/caotral/linker/writer.rb
@@ -1,9 +1,9 @@
-require_relative "elf/program_header"
+require "caotral/binary/elf"
 
 module Caotral
   class Linker
     class Writer
-      include Caotral::Assembler::ELF::Utils
+      include Caotral::Binary::ELF::Utils
       ALLOW_SECTIONS = %w(.text .strtab .shstrtab).freeze
       R_X86_64_PC32 = 2
       R_X86_64_PLT32 = 4
@@ -20,11 +20,11 @@ def write
         f = File.open(@output, "wb")
         phoffset, phnum, phsize, ehsize = 64, 1, 56, 64
         header = @elf_obj.header.set!(type: 2, phoffset:, phnum:, phsize:, ehsize:)
-        ph = Caotral::Linker::ELF::ProgramHeader.new
-        text_section = @elf_obj.sections[".text"]
+        ph = Caotral::Binary::ELF::ProgramHeader.new
+        text_section = @elf_obj.find_by_name(".text")
         rel_sections = @elf_obj.sections.select { RELOCATION_SECTION_NAMES.include?(it.section_name) }
         start_bytes = [0xe8, *[0] * 4, 0x48, 0x89, 0xc7, 0x48, 0xc7, 0xc0, 0x3c, 0x00, 0x00, 0x00, 0x0f, 0x05]
-        symtab = @elf_obj.sections[".symtab"]
+        symtab = @elf_obj.find_by_name(".symtab")
         symtab_body = symtab.body
         old_text = text_section.body
         main_sym = symtab_body.find { |sym| sym.name_string == "main" }
@@ -67,19 +67,19 @@ def write
         gap = [text_offset - f.pos, 0].max
         f.write("\0" * gap)
         f.write(text_section.body)
-        shstrtab = @elf_obj.sections[".shstrtab"]
+        shstrtab = @elf_obj.find_by_name(".shstrtab")
         shstrtab_offset = f.pos
         f.write(shstrtab.body.names)
         shstrtab.header.set!(offset: shstrtab_offset, size: shstrtab.body.names.bytesize)
-        write_sections = @elf_obj.sections.select { ALLOW_SECTIONS.include?(it.section_name) || it.name == "" }
+        write_sections = @elf_obj.sections.select { ALLOW_SECTIONS.include?(it.section_name) || it.section_name.nil? }
         shoffset = f.pos
         shstrndx = write_sections.index { it.section_name == ".shstrtab" }
         shnum = write_sections.size
         @elf_obj.header.set!(shoffset:, shnum:, shstrndx:)
-        names = @elf_obj.sections[".shstrtab"].body
+        names = @elf_obj.find_by_name(".shstrtab").body
 
         write_sections.each do |section|
-          lookup_name = section.name.sub(/\A\0/, "")
+          lookup_name = section.section_name
           name_offset = names.offset_of(lookup_name)
           section.header.set!(name: name_offset) if name_offset
           f.write(section.header.build)
diff --git a/sig/caotral/assembler.rbs b/sig/caotral/assembler.rbs
index 1f305dd..e5ae9d2 100644
--- a/sig/caotral/assembler.rbs
+++ b/sig/caotral/assembler.rbs
@@ -1,13 +1,12 @@
-use Caotral::Assembler::ELF
 class Caotral::Assembler
   @input: String
   @output: String
   @assembler: String
-  @elf: ELF
+  @asm_reader: Caotral::Assembler::Reader
   @debug: bool
 
-  def initialize: (input: String, ?output: String, ?type: Symbol, ?debug: bool) -> void
-  def assemble: (?assembler: String, ?assembler_options: Array[String] | [], ?input: String, ?output: String, ?debug: bool) -> String
+  def initialize: (input: String, ?output: String, ?assembler: String, ?type: Symbol, ?debug: bool) -> void
+  def assemble: (?assembler: String, ?assembler_options: Array[String] | [], ?input: String, ?output: String, ?debug: bool, ?shared: bool) -> String
   def obj_file: () -> String
-  def to_elf: (?input: String, ?output: String, ?debug: bool) -> void
+  def to_elf: (?input: String, ?output: String, ?debug: bool) -> String
 end
diff --git a/sig/caotral/assembler/builder.rbs b/sig/caotral/assembler/builder.rbs
new file mode 100644
index 0000000..30712b8
--- /dev/null
+++ b/sig/caotral/assembler/builder.rbs
@@ -0,0 +1,6 @@
+class Caotral::Assembler::Builder
+  @instructions: Hash[String, Array[String]]
+
+  def initialize: (instructions: Hash[String, Array[String]]) -> void
+  def build: () -> Caotral::Binary::ELF
+end
diff --git a/sig/caotral/assembler/builder/text.rbs b/sig/caotral/assembler/builder/text.rbs
new file mode 100644
index 0000000..8538de3
--- /dev/null
+++ b/sig/caotral/assembler/builder/text.rbs
@@ -0,0 +1,13 @@
+class Caotral::Assembler::Builder::Text
+  @instructions: Hash[String, Array[String]]
+  @entries: Array[Hash[Symbol, untyped]]
+  @label_positions: Hash[String, Integer]
+
+  attr_reader entries: Array[Hash[Symbol, untyped]]
+
+  def initialize: (instructions: Hash[String, Array[String]]) -> void
+  def assemble!: (String) -> void
+  def build: () -> String
+  def size: () -> Integer
+  def align: (Integer, Integer) -> void
+end
diff --git a/sig/caotral/assembler/elf/header.rbs b/sig/caotral/assembler/elf/header.rbs
index 73939cc..27d7fa9 100644
--- a/sig/caotral/assembler/elf/header.rbs
+++ b/sig/caotral/assembler/elf/header.rbs
@@ -1,30 +1,2 @@
-class Caotral::Assembler::ELF::Header
-  IDENT: Array[Integer]
-  ELF_FILE_TYPE: Hash[Symbol, Integer]
-
-  @e_ident: Array[Integer]
-  @type: Integer
-  @arch: Array[Integer]
-  @version: Array[Integer]
-  @entry: Array[Integer]?
-  @phoffset: Array[Integer]?
-  @shoffset: Array[Integer]?
-  @flags: Array[Integer]
-  @ehsize: Array[Integer]
-  @phsize: Array[Integer]
-  @ehnum: Array[Integer]
-  @shentsize: Array[Integer]
-  @shnum: Array[Integer]?
-  @shstrndx: Array[Integer]?
-
-  def initialize: (?endian: Symbol, ?type: Symbol, ?arche: Symbol) -> void
-  def build: () -> String
-  def set!: (?entry: Integer?, ?phoffset: Integer?, ?shoffset: Integer?, ?shnum: Integer?, ?shstrndx: Integer?) -> void
-
-  private
-  def check: (Array[Integer] | Integer, Integer) -> bool
-  def num2bytes: (Integer, Integer) -> Array[Integer]
-  def bytes: () -> Array[Array[Integer]]
-  def arch: (String | Symbol) -> Array[Integer]
-  def elf: (String | Symbol) -> Symbol
+class Caotral::Assembler::ELF::Header < Caotral::Binary::ELF::Header
 end
diff --git a/sig/caotral/assembler/elf/section_header.rbs b/sig/caotral/assembler/elf/section_header.rbs
index 1fb5aab..837aea5 100644
--- a/sig/caotral/assembler/elf/section_header.rbs
+++ b/sig/caotral/assembler/elf/section_header.rbs
@@ -1,24 +1,10 @@
-use Caotral::Assembler::ELF
-
-class Caotral::Assembler::ELF::SectionHeader
-  @name: Array[Integer]?
-  @type: Array[Integer]?
-  @flags: Array[Integer]?
-  @addr: Array[Integer]?
-  @offset: Array[Integer]?
-  @size: Array[Integer]?
-  @link: Array[Integer]?
-  @info: Array[Integer]?
-  @addralign: Array[Integer]?
-  @entsize: Array[Integer]?
-
-  def build: () -> String
-  def set!: (?name: Integer?, ?type: Integer?, ?flags: Integer?, ?addr: Integer?, ?offset: Integer?, ?size: Integer?, ?link: Integer?, ?info: Integer?, ?addralign: Integer?, ?entsize: Integer?) -> Caotral::Assembler::ELF::SectionHeader
-  def null!: () -> ELF::SectionHeader
-  def text!: () -> ELF::SectionHeader
-  def note!: () -> ELF::SectionHeader
-
-  private def bytes: () -> Array[Array[Integer]?]
-  private def check: ((Array[Integer] | Integer)?, Integer) -> bool
-  private def num2bytes: (Integer?, Integer) -> Array[Integer]
+class Caotral::Assembler::ELF::SectionHeader < Caotral::Binary::ELF::SectionHeader
+  def null!: () -> Caotral::Assembler::ELF::SectionHeader
+  def text!: () -> Caotral::Assembler::ELF::SectionHeader
+  def data!: () -> Caotral::Assembler::ELF::SectionHeader
+  def bss!: () -> Caotral::Assembler::ELF::SectionHeader
+  def note!: () -> Caotral::Assembler::ELF::SectionHeader
+  def symtab!: () -> Caotral::Assembler::ELF::SectionHeader
+  def strtab!: () -> Caotral::Assembler::ELF::SectionHeader
+  def shstrtab!: () -> Caotral::Assembler::ELF::SectionHeader
 end
diff --git a/sig/caotral/assembler/elf/utils.rbs b/sig/caotral/assembler/elf/utils.rbs
deleted file mode 100644
index 2641788..0000000
--- a/sig/caotral/assembler/elf/utils.rbs
+++ /dev/null
@@ -1,13 +0,0 @@
-use Caotral::Assembler::ELF::Error
-
-module Caotral::Assembler::ELF::Utils
-  def build: () -> String
-  def size: () -> Integer
-  def empties: () -> Array[Symbol]
-  private def align: (Array[Integer], Integer) -> void
-  private def check: ((Array[Integer] | Integer)?, Integer) -> bool
-  private def num2bytes: (Integer, Integer) -> Array[Integer]
-  private def bytes: () -> Array[Array[Integer]?]
-  private def hexas: (Integer, Integer) -> Array[Integer]
-  private def must_be_filled_section_fields: () -> Array[Symbol]
-end
diff --git a/sig/caotral/assembler/reader.rbs b/sig/caotral/assembler/reader.rbs
new file mode 100644
index 0000000..b771867
--- /dev/null
+++ b/sig/caotral/assembler/reader.rbs
@@ -0,0 +1,10 @@
+class Caotral::Assembler::Reader
+  @input: String
+  @debug: bool
+  @instructions: Hash[String, Array[String]]
+
+  attr_reader instructions: Hash[String, Array[String]]
+
+  def initialize: (input: String, ?debug: bool) -> void
+  def read: () -> Hash[String, Array[String]]
+end
diff --git a/sig/caotral/assembler/writer.rbs b/sig/caotral/assembler/writer.rbs
new file mode 100644
index 0000000..8119e75
--- /dev/null
+++ b/sig/caotral/assembler/writer.rbs
@@ -0,0 +1,9 @@
+class Caotral::Assembler::Writer
+  @elf_obj: Caotral::Binary::ELF
+  @output: String
+  @debug: bool
+
+  def self.write!: (elf_obj: Caotral::Binary::ELF, output: String, ?debug: bool) -> String
+  def initialize: (elf_obj: Caotral::Binary::ELF, output: String, ?debug: bool) -> void
+  def write: (?output: String) -> String
+end
diff --git a/sig/caotral/binary.rbs b/sig/caotral/binary.rbs
new file mode 100644
index 0000000..a1cfd6c
--- /dev/null
+++ b/sig/caotral/binary.rbs
@@ -0,0 +1,2 @@
+module Caotral::Binary
+end
diff --git a/sig/caotral/binary/elf.rbs b/sig/caotral/binary/elf.rbs
new file mode 100644
index 0000000..e7bb7a8
--- /dev/null
+++ b/sig/caotral/binary/elf.rbs
@@ -0,0 +1,13 @@
+class Caotral::Binary::ELF
+  include Enumerable[Caotral::Binary::ELF::Section]
+
+  attr_reader sections: Array[Caotral::Binary::ELF::Section]
+  attr_accessor header: Caotral::Binary::ELF::Header?
+
+  def initialize: () -> void
+  def each: () { (Caotral::Binary::ELF::Section) -> void } -> Array[Caotral::Binary::ELF::Section]
+  def []: (Integer) -> Caotral::Binary::ELF::Section?
+  def find_by_name: (String | Symbol) -> Caotral::Binary::ELF::Section?
+  def select_by_name: (String | Symbol) -> Array[Caotral::Binary::ELF::Section]
+  def index: (String | Symbol) -> Integer?
+end
diff --git a/sig/caotral/binary/elf/header.rbs b/sig/caotral/binary/elf/header.rbs
new file mode 100644
index 0000000..689e995
--- /dev/null
+++ b/sig/caotral/binary/elf/header.rbs
@@ -0,0 +1,28 @@
+class Caotral::Binary::ELF::Header
+  IDENT: Array[Integer]
+  IDENT_STR: String
+  ELF_FILE_TYPE: Hash[Symbol, Integer]
+
+  def initialize: (?endian: Symbol, ?type: Symbol, ?arc: Symbol) -> void
+  def build: () -> String
+  def set!: (
+    ?type: Integer?,
+    ?entry: Integer?,
+    ?phoffset: Integer?,
+    ?shoffset: Integer?,
+    ?shnum: Integer?,
+    ?shstrndx: Integer?,
+    ?phsize: Integer?,
+    ?phnum: Integer?,
+    ?ehsize: Integer?
+  ) -> self
+
+  def entry: () -> Integer
+  def ehsize: () -> Integer
+  def phsize: () -> Integer
+  def phnum: () -> Integer
+  def shentsize: () -> Integer
+  def shnum: () -> Integer
+  def shstrndx: () -> Integer
+  def shoffset: () -> Integer
+end
diff --git a/sig/caotral/linker/elf/program_header.rbs b/sig/caotral/binary/elf/program_header.rbs
similarity index 86%
rename from sig/caotral/linker/elf/program_header.rbs
rename to sig/caotral/binary/elf/program_header.rbs
index e8391bf..75b13a3 100644
--- a/sig/caotral/linker/elf/program_header.rbs
+++ b/sig/caotral/binary/elf/program_header.rbs
@@ -1,4 +1,4 @@
-class Caotral::Linker::ELF::ProgramHeader
+class Caotral::Binary::ELF::ProgramHeader
   def initialize: () -> void
   def build: () -> String
   def set!: (
diff --git a/sig/caotral/binary/elf/reader.rbs b/sig/caotral/binary/elf/reader.rbs
new file mode 100644
index 0000000..79159fa
--- /dev/null
+++ b/sig/caotral/binary/elf/reader.rbs
@@ -0,0 +1,11 @@
+class Caotral::Binary::ELF::Reader
+  @input: File
+  @bin: StringIO
+  @context: Caotral::Binary::ELF
+
+  attr_reader context: Caotral::Binary::ELF
+
+  def self.read!: (input: String | Pathname, ?debug: bool, ?linker_options: Array[String]) -> Caotral::Binary::ELF
+  def initialize: (input: String | Pathname, ?debug: bool, ?linker_options: Array[String]) -> void
+  def read: () -> Caotral::Binary::ELF
+end
diff --git a/sig/caotral/binary/elf/section.rbs b/sig/caotral/binary/elf/section.rbs
new file mode 100644
index 0000000..9933f46
--- /dev/null
+++ b/sig/caotral/binary/elf/section.rbs
@@ -0,0 +1,11 @@
+class Caotral::Binary::ELF::Section
+  attr_reader header: Caotral::Binary::ELF::SectionHeader
+  attr_accessor body: untyped
+  attr_accessor section_name: String?
+
+  def initialize: (
+    header: Caotral::Binary::ELF::SectionHeader,
+    body: untyped,
+    section_name: String?
+  ) -> void
+end
diff --git a/sig/caotral/binary/elf/section/rel.rbs b/sig/caotral/binary/elf/section/rel.rbs
new file mode 100644
index 0000000..cc2e588
--- /dev/null
+++ b/sig/caotral/binary/elf/section/rel.rbs
@@ -0,0 +1,11 @@
+class Caotral::Binary::ELF::Section::Rel
+  def initialize: (?addend: bool) -> void
+  def set!: (?offset: Integer?, ?info: Integer?, ?addend: Integer?) -> self
+  def build: () -> String
+  def offset: () -> Integer
+  def info: () -> Integer
+  def addend: () -> Integer
+  def sym: () -> Integer
+  def type: () -> Integer
+  def addend?: () -> bool
+end
diff --git a/sig/caotral/linker/elf/section/strtab.rbs b/sig/caotral/binary/elf/section/strtab.rbs
similarity index 66%
rename from sig/caotral/linker/elf/section/strtab.rbs
rename to sig/caotral/binary/elf/section/strtab.rbs
index e5d3c8d..cfbee73 100644
--- a/sig/caotral/linker/elf/section/strtab.rbs
+++ b/sig/caotral/binary/elf/section/strtab.rbs
@@ -1,5 +1,5 @@
-class Caotral::Linker::ELF::Section::Strtab
-  attr_reader names: String
+class Caotral::Binary::ELF::Section::Strtab
+  attr_accessor names: String
 
   def initialize: (?String, **untyped) -> void
   def build: () -> String
diff --git a/sig/caotral/linker/elf/section/symtab.rbs b/sig/caotral/binary/elf/section/symtab.rbs
similarity index 67%
rename from sig/caotral/linker/elf/section/symtab.rbs
rename to sig/caotral/binary/elf/section/symtab.rbs
index 3a8c272..a69110d 100644
--- a/sig/caotral/linker/elf/section/symtab.rbs
+++ b/sig/caotral/binary/elf/section/symtab.rbs
@@ -1,7 +1,7 @@
-class Caotral::Linker::ELF::Section::Symtab
+class Caotral::Binary::ELF::Section::Symtab
   attr_accessor name_string: String
 
-  def initialize: (?opts: untyped) -> void
+  def initialize: (**untyped) -> void
   def set!: (
     ?name: Integer?,
     ?info: Integer?,
@@ -10,5 +10,7 @@ class Caotral::Linker::ELF::Section::Symtab
     ?value: Integer?,
     ?size: Integer?
   ) -> self
+
   def name_offset: () -> Integer
+  def value: () -> Integer
 end
diff --git a/sig/caotral/linker/elf/section_header.rbs b/sig/caotral/binary/elf/section_header.rbs
similarity index 80%
rename from sig/caotral/linker/elf/section_header.rbs
rename to sig/caotral/binary/elf/section_header.rbs
index a6c9917..8155d34 100644
--- a/sig/caotral/linker/elf/section_header.rbs
+++ b/sig/caotral/binary/elf/section_header.rbs
@@ -1,8 +1,6 @@
-class Caotral::Linker::ELF::SectionHeader
+class Caotral::Binary::ELF::SectionHeader
   SHT: Hash[Symbol, Integer]
   SHT_BY_VALUE: Hash[Integer, Symbol]
-  LONG_TYPES: Array[String]
-  INT_TYPES: Array[String]
 
   def initialize: () -> void
   def build: () -> String
@@ -18,10 +16,12 @@ class Caotral::Linker::ELF::SectionHeader
     ?addralign: Integer?,
     ?entsize: Integer?
   ) -> self
-  def null!: () -> self
+
   def name: () -> Integer
   def offset: () -> Integer
   def entsize: () -> Integer
   def size: () -> Integer
+  def type: () -> Symbol?
   def info: () -> Integer
+  def addr: () -> Integer
 end
diff --git a/sig/caotral/linker.rbs b/sig/caotral/linker.rbs
index 493aabe..f87cd68 100644
--- a/sig/caotral/linker.rbs
+++ b/sig/caotral/linker.rbs
@@ -13,5 +13,5 @@ class Caotral::Linker
   def link_command: (input: String, ?output: String, ?shared: bool, ?debug: bool) -> String
   def libpath: () -> String
   def gcc_libpath: () -> String
-  def to_elf: (input: String, ?output: String, ?debug: bool) -> void
+  def to_elf: (input: String, ?output: String, ?debug: bool) -> String
 end
diff --git a/sig/caotral/linker/elf.rbs b/sig/caotral/linker/elf.rbs
deleted file mode 100644
index a295925..0000000
--- a/sig/caotral/linker/elf.rbs
+++ /dev/null
@@ -1,3 +0,0 @@
-class Caotral::Linker::ELF
-  def initialize: () -> void
-end
diff --git a/sig/caotral/linker/elf/header.rbs b/sig/caotral/linker/elf/header.rbs
deleted file mode 100644
index 1593ffc..0000000
--- a/sig/caotral/linker/elf/header.rbs
+++ /dev/null
@@ -1,13 +0,0 @@
-class Caotral::Linker::ELF::Header
-  def set!: (
-    ?type: Integer?,
-    ?entry: Integer?,
-    ?phoffset: Integer?,
-    ?shoffset: Integer?,
-    ?shnum: Integer?,
-    ?shstrndx: Integer?,
-    ?phsize: Integer?,
-    ?phnum: Integer?,
-    ?ehsize: Integer?
-  ) -> self
-end
diff --git a/sig/caotral/linker/elf/section.rbs b/sig/caotral/linker/elf/section.rbs
deleted file mode 100644
index 2d7b111..0000000
--- a/sig/caotral/linker/elf/section.rbs
+++ /dev/null
@@ -1,8 +0,0 @@
-class Caotral::Linker::ELF::Section
-  attr_accessor header: untyped
-  attr_accessor body: untyped
-  attr_accessor section_name: String
-
-  def initialize: (type: Symbol, ?section_name: String?, ?options: Hash[Symbol, untyped]) -> void
-  def name: () -> String
-end
diff --git a/sig/caotral/linker/elf/section/rel.rbs b/sig/caotral/linker/elf/section/rel.rbs
deleted file mode 100644
index 6176c32..0000000
--- a/sig/caotral/linker/elf/section/rel.rbs
+++ /dev/null
@@ -1,12 +0,0 @@
-class Caotral::Linker::ELF::Section::Rel
-  def initialize: (?addend: bool) -> void
-  def set!: (
-    ?offset: Integer?,
-    ?info: Integer?,
-    ?addend: Integer?
-  ) -> self
-  def build: () -> String
-  def offset: () -> Integer
-  def info: () -> Integer
-  def addend: () -> Integer
-end
diff --git a/sig/caotral/linker/reader.rbs b/sig/caotral/linker/reader.rbs
deleted file mode 100644
index 689f5e4..0000000
--- a/sig/caotral/linker/reader.rbs
+++ /dev/null
@@ -1,5 +0,0 @@
-class Caotral::Linker::Reader
-  def self.read!: (input: String, ?debug: bool, ?linker_options: Array[String]) -> Caotral::Linker::ELF
-  def initialize: (input: String, ?debug: bool, ?linker_options: Array[String]) -> void
-  def read: () -> Caotral::Linker::ELF
-end
diff --git a/sig/caotral/linker/writer.rbs b/sig/caotral/linker/writer.rbs
index d4d5f9d..d47f1ef 100644
--- a/sig/caotral/linker/writer.rbs
+++ b/sig/caotral/linker/writer.rbs
@@ -1,5 +1,5 @@
 class Caotral::Linker::Writer
-  def self.write!: (elf_obj: Caotral::Linker::ELF, output: String, ?entry: Integer, ?debug: bool) -> String
-  def initialize: (elf_obj: Caotral::Linker::ELF, output: String, ?entry: Integer, ?debug: bool) -> void
+  def self.write!: (elf_obj: Caotral::Binary::ELF, output: String, ?entry: Integer, ?debug: bool) -> String
+  def initialize: (elf_obj: Caotral::Binary::ELF, output: String, ?entry: Integer, ?debug: bool) -> void
   def write: () -> String
 end
diff --git a/test/caotral/assembler/binary/elf/jump_test.rb b/test/caotral/assembler/binary/elf/jump_test.rb
index 6e06202..157e527 100644
--- a/test/caotral/assembler/binary/elf/jump_test.rb
+++ b/test/caotral/assembler/binary/elf/jump_test.rb
@@ -8,7 +8,9 @@ def test_forward_jump
     output = "jmp_forward.o"
 
     assembler = Caotral::Assembler.new(input:, output:)
-    _header, _null, text, = assembler.to_elf
+    assembler.to_elf
+    elf_obj = Caotral::Binary::ELF::Reader.new(input: output).read
+    text = elf_obj.find_by_name(".text")
 
     expected = [
       0x55, # push rbp
@@ -22,7 +24,7 @@ def test_forward_jump
       0xc3, # ret
     ]
 
-    assert_equal(expected, text.unpack("C*")[...expected.size])
+    assert_equal(expected, text.body.unpack("C*")[...expected.size])
   ensure
     File.delete(output) if File.exist?(output)
   end
@@ -32,7 +34,9 @@ def test_backward_jump
     output = "jmp_backward.o"
 
     assembler = Caotral::Assembler.new(input:, output:)
-    _header, _null, text, = assembler.to_elf
+    assembler.to_elf
+    elf_obj = Caotral::Binary::ELF::Reader.new(input: output).read
+    text = elf_obj.find_by_name(".text")
 
     expected = [
       0x55, # push rbp
@@ -46,7 +50,7 @@ def test_backward_jump
       0xc3, # ret
     ]
 
-    assert_equal(expected, text.unpack("C*")[...expected.size])
+    assert_equal(expected, text.body.unpack("C*")[...expected.size])
   ensure
     File.delete(output) if File.exist?(output)
   end
diff --git a/test/caotral/assembler/binary/elf/lea_addr_test.rb b/test/caotral/assembler/binary/elf/lea_addr_test.rb
index fac54af..c239eae 100644
--- a/test/caotral/assembler/binary/elf/lea_addr_test.rb
+++ b/test/caotral/assembler/binary/elf/lea_addr_test.rb
@@ -8,7 +8,9 @@ def test_lea_addr
     output = "lea_addr.o"
 
     assembler = Caotral::Assembler.new(input:, output:)
-    _header, _null, text, = assembler.to_elf
+    assembler.to_elf
+    elf_obj = Caotral::Binary::ELF::Reader.new(input: output).read
+    text = elf_obj.find_by_name(".text").body
 
     expected = [
       0x55,
diff --git a/test/caotral/assembler/binary/elf/xor_test.rb b/test/caotral/assembler/binary/elf/xor_test.rb
index 743f15e..1cec1ec 100644
--- a/test/caotral/assembler/binary/elf/xor_test.rb
+++ b/test/caotral/assembler/binary/elf/xor_test.rb
@@ -8,7 +8,9 @@ def test_xor_zero
     output = "xor_zero.o"
 
     assembler = Caotral::Assembler.new(input:, output:)
-    _header, _null, text, = assembler.to_elf
+    assembler.to_elf
+    elf_obj = Caotral::Binary::ELF::Reader.new(input: output).read
+    text = elf_obj.find_by_name(".text").body
 
     expected = [
       0x55, # push rbp
diff --git a/test/caotral/assembler/builder_test.rb b/test/caotral/assembler/builder_test.rb
new file mode 100644
index 0000000..00f5c9f
--- /dev/null
+++ b/test/caotral/assembler/builder_test.rb
@@ -0,0 +1,15 @@
+require "caotral"
+require "test/unit"
+require "pathname"
+
+class Caotral::Assembler::BuilderTest < Test::Unit::TestCase
+  def test_build
+    input = Pathname.pwd.join('sample', 'assembler', 'plus.s').to_s
+    instructions = Caotral::Assembler::Reader.new(input:).read
+    builder = Caotral::Assembler::Builder.new(instructions:).build
+  
+    assert_equal(0, builder.header.shoffset)
+    assert_equal(8, builder.header.shnum)
+    assert_equal(7, builder.header.shstrndx)
+  end
+end
diff --git a/test/caotral/assembler/elf/header_test.rb b/test/caotral/assembler/elf/header_test.rb
deleted file mode 100644
index b6fe3d9..0000000
--- a/test/caotral/assembler/elf/header_test.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-require "caotral"
-require "test/unit"
-
-class Caotral::Assembler::ELF::HeaderTest < Test::Unit::TestCase
-  def setup = @elf_header = Caotral::Assembler::ELF::Header.new
-
-  def test_build_elf_header
-    # TODO: ELF Header Section binary
-  end
-end
diff --git a/test/caotral/assembler/elf/section/note_test.rb b/test/caotral/assembler/elf/section/note_test.rb
deleted file mode 100644
index 4e67160..0000000
--- a/test/caotral/assembler/elf/section/note_test.rb
+++ /dev/null
@@ -1,18 +0,0 @@
-require "caotral"
-require "test/unit"
-
-class Caotral::Assembler::ELF::Section::NoteTest < Test::Unit::TestCase
-  def reference_binary = "\x04\x00\x00\x00 \x00\x00\x00\x05\x00\x00\x00GNU\x00\x02\x00\x01\xC0\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x01\xC0\x04\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00".force_encoding("ASCII-8BIT")
-  def setup = @note = Caotral::Assembler::ELF::Section::Note.new
-
-  def test_gnu_property!
-    assert_equal(
-      Caotral::Assembler::ELF::Section::Note.gnu_property,
-      reference_binary
-    )
-    assert_equal(
-      @note.gnu_property!.build,
-      reference_binary
-    )
-  end
-end
diff --git a/test/caotral/assembler/elf/section/shstrtab_test.rb b/test/caotral/assembler/elf/section/shstrtab_test.rb
deleted file mode 100644
index ecccd44..0000000
--- a/test/caotral/assembler/elf/section/shstrtab_test.rb
+++ /dev/null
@@ -1,18 +0,0 @@
-require "caotral"
-require "test/unit"
-
-class Caotral::Assembler::ELF::Section::TestShstrtab < Test::Unit::TestCase
-  def setup = @shstrtab = Caotral::Assembler::ELF::Section::Shstrtab.new
-  def test_set_values
-    binary = "\x00.text\x00".force_encoding("ASCII-8BIT")
-    @shstrtab.set!(name: "text")
-    assert_equal(@shstrtab.build, binary)
-    binary = "\x00.text\x00.strtab\x00".force_encoding("ASCII-8BIT")
-    @shstrtab.set!(name: "strtab")
-    assert_equal(@shstrtab.build, binary)
-  end
-  def test_alert_values
-    assert_raise(Caotral::Assembler::ELF::Error) { @shstrtab.set!(name: :main) }
-    assert_raise(Caotral::Assembler::ELF::Error) { @shstrtab.set!(name: 123) }
-  end
-end
diff --git a/test/caotral/assembler/elf/section/symtab_test.rb b/test/caotral/assembler/elf/section/symtab_test.rb
deleted file mode 100644
index 05d2732..0000000
--- a/test/caotral/assembler/elf/section/symtab_test.rb
+++ /dev/null
@@ -1,21 +0,0 @@
-require "caotral"
-require "test/unit"
-
-class Caotral::Assembler::ELF::Section::TestSymtab < Test::Unit::TestCase
-  def setup = @symtab = Caotral::Assembler::ELF::Section::Symtab.new
-
-  def test_default_values
-    binary = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00".force_encoding("ASCII-8BIT")
-    assert_equal(@symtab.build, binary)
-  end
-
-  def test_main_value
-    binary = "\x01\x00\x02\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00".force_encoding("ASCII-8BIT")
-    @symtab.set!(name: [1, 0, 2, 1])
-    assert_equal(@symtab.build, binary)
-    @symtab.set!(name: 16908289)
-    assert_equal(@symtab.build, binary)
-    @symtab.set!(name: "\x01\x00\x02\x01".force_encoding("ASCII-8BIT"))
-    assert_equal(@symtab.build, binary)
-  end
-end
diff --git a/test/caotral/assembler/elf/section_header_test.rb b/test/caotral/assembler/elf/section_header_test.rb
deleted file mode 100644
index 900e0d9..0000000
--- a/test/caotral/assembler/elf/section_header_test.rb
+++ /dev/null
@@ -1,11 +0,0 @@
-require "caotral"
-require "test/unit"
-
-class Caotral::Assembler::ELF::SectionHeaderTest < Test::Unit::TestCase
-  def setup = @section_header = Caotral::Assembler::ELF::SectionHeader.new
-  def test_null!
-    assert(@section_header.null!)
-    assert_equal(@section_header.build.size, 64)
-    assert_equal(@section_header.build, [[0] * 4, [0] * 4, [0] * 8, [0] * 8, [0] * 8, [0] * 8, [0] * 4, [0] * 4, [0] * 8, [0] * 8].flatten.pack("C*"))
-  end
-end
diff --git a/test/caotral/assembler/writer_test.rb b/test/caotral/assembler/writer_test.rb
new file mode 100644
index 0000000..d16d36f
--- /dev/null
+++ b/test/caotral/assembler/writer_test.rb
@@ -0,0 +1,23 @@
+require "caotral"
+require "test/unit"
+require "pathname"
+
+class Caotral::Assembler::WriterTest < Test::Unit::TestCase
+  def test_write
+    input = Pathname.pwd.join('sample', 'assembler', 'plus.s').to_s
+    output = "amd64.o"
+    instructions = Caotral::Assembler::Reader.new(input:).read
+    elf_obj = Caotral::Assembler::Builder.new(instructions:).build
+    writer = Caotral::Assembler::Writer.new(elf_obj:, output:).write
+    results = Caotral::Binary::ELF::Reader.new(input: output).read
+    shstrtab = results.find_by_name(".shstrtab")
+    text = results.find_by_name(".text")
+    names = shstrtab.body.names
+    assert_include(names, ".text")
+    assert_include(names, ".strtab")
+    assert_include(names, ".symtab")
+    assert_include(names, ".shstrtab")
+    assert_equal(text.body.unpack("C*"), ref_text)
+  end
+  def ref_text = [85, 72, 137, 229, 72, 131, 236, 0, 106, 1, 106, 2, 95, 88, 72, 1, 248, 80, 106, 3, 95, 88, 72, 15, 175, 199, 80, 106,5, 106, 4, 95, 88, 72, 41, 248, 80, 95, 88, 72, 153, 72, 247, 255, 80, 72, 137, 236, 93, 72, 137, 199, 72, 199, 192, 60, 0, 0, 0, 15, 5]
+end
diff --git a/test/caotral/assembler_test.rb b/test/caotral/assembler_test.rb
index 5a27538..f5ed07a 100644
--- a/test/caotral/assembler_test.rb
+++ b/test/caotral/assembler_test.rb
@@ -6,31 +6,13 @@
 class Caotral::Assembler::ELFTest < Test::Unit::TestCase
   def test_to_elf
     input = Pathname.pwd.join('sample', 'assembler', 'plus.s').to_s
-
-    assembler = Caotral::Assembler.new(input:, output: "amd64.o")
-    header, null, text, data, bss, note, symtab, strtab, shstrtab, *section_headers = assembler.to_elf
-    sh_null, sh_text, sh_data, sh_bss, sh_note, sh_symtab, sh_strtab, sh_shstrtab = section_headers
-    r_header, r_null, r_text, r_data, r_bss, r_note, r_symtab, r_strtab, r_shstrtab, *r_section_headers = dumped_references
-    r_sh_null, r_sh_text, r_sh_data, r_sh_bss, r_sh_note, r_sh_symtab, r_sh_strtab, r_sh_shstrtab = r_section_headers
-    assert_equal(r_header, header.unpack("C*"))
-    assert_equal(r_null, null.unpack("C*"))
-    assert_equal(r_data, data.unpack("C*"))
-    # remove alignment bytes
-    assert_equal(r_text, text.unpack("C*")[..-7])
-    assert_equal(r_bss, bss.unpack("C*"))
-    assert_equal(r_note, note.unpack("C*"))
-    assert_equal(r_symtab, symtab.unpack("C*"))
-    assert_equal(r_strtab, strtab.unpack("C*"))
-    ref_shstrtab = r_shstrtab.pack("C*").split("\0").select { |str| str.size > 0 }.sort
-    assert(ref_shstrtab.zip(shstrtab.split("\0").select { |str| str.size > 0 }.sort).all? { |ref, act| ref =~ /#{act}/ })
-    assert_equal(r_sh_null, sh_null.unpack("C*"))
-    assert_equal(r_sh_text, sh_text.unpack("C*"))
-    assert_equal(r_sh_data, sh_data.unpack("C*"))
-    assert_equal(r_sh_bss, sh_bss.unpack("C*"))
-    assert_equal(r_sh_note, sh_note.unpack("C*"))
-    assert_equal(r_sh_symtab, sh_symtab.unpack("C*"))
-    assert_equal(r_sh_strtab, sh_strtab.unpack("C*"))
-    assert_equal(r_sh_shstrtab, sh_shstrtab.unpack("C*"))
+    output = "amd64.o"
+    Caotral::Assembler.new(input:, output:).to_elf
+    results = Caotral::Binary::ELF::Reader.new(input: output).read
+    text = results.find_by_name(".text")
+    symtab = results.find_by_name(".symtab")
+    assert_equal(ref_text, text.body.unpack("C*"))
+    assert_equal(ref_symtab, symtab.body.map(&:build).map { it.unpack("C*") }.flatten)
     File.delete("amd64.o")
   end
 
@@ -44,16 +26,16 @@ def test_assembler_command
     assert_raise(Caotral::Assembler::Error) { assembler.command("foo") }
   end
 
+  def ref_elf_header = [127, 69, 76, 70, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 62, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 0, 0, 64, 0, 8, 0, 7, 0]
+  def ref_text = [85, 72, 137, 229, 72, 131, 236, 0, 106, 1, 106, 2, 95, 88, 72, 1, 248, 80, 106, 3, 95, 88, 72, 15, 175, 199, 80, 106,5, 106, 4, 95, 88, 72, 41, 248, 80, 95, 88, 72, 153, 72, 247, 255, 80, 72, 137, 236, 93, 72, 137, 199, 72, 199, 192, 60, 0, 0, 0, 15, 5]
+  def ref_symtab = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 18, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0, 0]
   def dumped_references
     [
-      [127, 69, 76, 70, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 62, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 0, 0, 64, 0, 8, 0, 7, 0], # elf header
-      [], # null section
-      [85, 72, 137, 229, 72, 131, 236, 0, 106, 1, 106, 2, 95, 88, 72, 1, 248, 80, 106, 3, 95, 88, 72, 15, 175, 199, 80, 106,5, 106, 4, 95, 88, 72, 41, 248, 80, 95, 88, 72, 153, 72, 247, 255, 80, 72, 137, 236, 93, 72, 137, 199, 72, 199, 192, 60, 0, 0], # text section
       [], # data section
       [], # bss section
       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 78, 85, 76, 76, 0, 0, 0, 0],#
       # [4, 0, 0, 0, 32, 0, 0, 0, 5, 0, 0, 0, 71, 78, 85, 0, 2, 0, 1, 192, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 192, 4, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0], # note section
-      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 16, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0, 0], # symtab section
+      
       [0, 109, 97, 105, 110, 0], # strtab section 
       [0, 46, 115, 121, 109, 116, 97, 98, 0, 46, 115, 116, 114, 116, 97, 98, 0, 46, 115, 104, 115, 116, 114, 116, 97, 98, 0,46, 116, 101, 120, 116, 0, 46, 100, 97, 116, 97, 0, 46, 98, 115, 115, 0, 46, 110, 111, 116, 101, 46, 103, 110, 117, 46, 112, 114, 111, 112, 101, 114, 116, 121, 0], # shstrtab section
       # section headers 
diff --git a/test/caotral/linker/reader_test.rb b/test/caotral/binary/elf/reader_test.rb
similarity index 52%
rename from test/caotral/linker/reader_test.rb
rename to test/caotral/binary/elf/reader_test.rb
index 9e02530..e64e475 100644
--- a/test/caotral/linker/reader_test.rb
+++ b/test/caotral/binary/elf/reader_test.rb
@@ -1,16 +1,17 @@
 require "caotral"
 require "test/unit"
-class Caotral::Linker::ReaderTest < Test::Unit::TestCase
+
+class Caotral::Binary::ELF::ReaderTest < Test::Unit::TestCase
   def setup = Caotral.assemble(input: "sample/assembler/plus.s", output: "plus.o", assembler: "self")
   def teardown = File.delete("plus.o") if File.exist?("plus.o")
   def test_read
-    elf_obj = Caotral::Linker::Reader.read!(input: "plus.o", debug: false)
-    assert_equal elf_obj.header.shoffset.pack("C*").unpack("Q<").first, 264
-    assert_equal elf_obj.sections.size, 8
-    assert_equal elf_obj.sections[0].section_name, "null"
+    elf_obj = Caotral::Binary::ELF::Reader.read!(input: "plus.o", debug: false)
+    assert_equal elf_obj.header.shoffset, 213
+    assert_equal elf_obj.sections.size, 5
+    assert_equal elf_obj.sections[0].section_name, nil
     shstrtab = elf_obj.sections[elf_obj.header.shstrndx]
     assert_equal shstrtab.section_name, ".shstrtab"
-    assert_equal shstrtab.body.names, "\0.text\0.data\0.bss\0.note\0.symtab\0.strtab\0.shstrtab\0"
+    assert_equal shstrtab.body.names, "\0\0.text\0.strtab\0.symtab\0.shstrtab\0".b
     assert_equal elf_obj.sections[1].section_name, ".text"
     assert_equal elf_obj.sections[1].header.size, 61
   end
diff --git a/test/caotral/compiler_test.rb b/test/caotral/compiler_test.rb
index 3b78871..2051cc6 100644
--- a/test/caotral/compiler_test.rb
+++ b/test/caotral/compiler_test.rb
@@ -9,7 +9,8 @@ def teardown
   end
   def test_sample_plus
     @file = "sample/plus.rb"
-    @caotral = Caotral.compile!(input: @file, assembler: "self")
+    @caotral = Caotral.compile!(input: @file, assembler: "self", linker: "self")
+    File.chmod(755, "tmp")
     IO.popen("./tmp").close
     exit_code, handle_code = check_process($?.to_i)
     assert_equal(9, exit_code)
@@ -19,6 +20,7 @@ def test_sample_plus
   def test_sample_variable
     @file = "sample/variable.rb"
     @caotral = Caotral.compile!(input: @file, assembler: "self")
+    File.chmod(755, "tmp")
     IO.popen("./tmp").close
     exit_code, handle_code = check_process($?.to_i)
     assert_equal(1, exit_code)
diff --git a/test/caotral/linker/writer_test.rb b/test/caotral/linker/writer_test.rb
index 2c544bf..2d4fcc2 100644
--- a/test/caotral/linker/writer_test.rb
+++ b/test/caotral/linker/writer_test.rb
@@ -3,7 +3,7 @@
 class Caotral::Linker::WriterTest < Test::Unit::TestCase
   def setup
     Caotral.assemble(input: "sample/assembler/plus.s", assembler: "self", output: "plus.o")
-    @elf_obj = Caotral::Linker::Reader.read!(input: "plus.o", debug: false)
+    @elf_obj = Caotral::Binary::ELF::Reader.read!(input: "plus.o", debug: false)
   end
   def teardown
     File.delete("plus.o") if File.exist?("plus.o")
@@ -14,10 +14,10 @@ def teardown
   end
   def test_write
     written_output = Caotral::Linker::Writer.write!(elf_obj: @elf_obj, output: "write.o", debug: false)
-    read_written_elf = Caotral::Linker::Reader.read!(input: written_output, debug: false)
-    assert_equal @elf_obj.header.shoffset.pack("C*").unpack("Q<").first, read_written_elf.header.shoffset.pack("C*").unpack("Q<").first
+    read_written_elf = Caotral::Binary::ELF::Reader.read!(input: written_output, debug: false)
+    assert_equal @elf_obj.header.shoffset, read_written_elf.header.shoffset
     assert_equal 4, read_written_elf.sections.size
-    assert_equal 0x401000, read_written_elf.header.entry.pack("C*").unpack("Q<").first
+    assert_equal 0x401000, read_written_elf.header.entry
   end
 
   def test_execute_written
@@ -31,7 +31,7 @@ def test_execute_written
 
   def test_relocation_write_and_execute
     IO.popen("gcc -c -fno-pic -fno-pie -o relocatable.o sample/C/rel_text.c").close
-    elf_obj = Caotral::Linker::Reader.read!(input: "relocatable.o", debug: false)
+    elf_obj = Caotral::Binary::ELF::Reader.read!(input: "relocatable.o", debug: false)
     Caotral::Linker::Writer.write!(elf_obj:, output: "relocated_exec", debug: false)
     File.chmod(0755, "./relocated_exec")
     IO.popen("./relocated_exec").close