├── .bochsrc
├── LICENSE
├── Makefile
├── README.md
├── buildhddimg
    ├── LICENSE
    └── buildhddimg.sh
├── linker.ld
├── loader.S
├── movdbz-addition.s
├── movdbz-as.py
├── run_movdbz_program.c
├── screen.c
├── screen.h
├── set_gdtr.S
├── setup.c
└── setup.h


/.bochsrc:
--------------------------------------------------------------------------------
 1 | # configuration file generated by Bochs
 2 | plugin_ctrl: unmapped=1, biosdev=1, speaker=1, extfpuirq=1, gameport=1, pci_ide=1, acpi=1, ioapic=1
 3 | config_interface: textconfig
 4 | display_library: sdl
 5 | memory: host=2048, guest=2048
 6 | romimage: file="/usr/share/bochs/BIOS-bochs-latest"
 7 | vgaromimage: file="/usr/share/bochs/VGABIOS-lgpl-latest"
 8 | boot: disk
 9 | floppy_bootsig_check: disabled=0
10 | # no floppya
11 | # no floppyb
12 | ata0: enabled=1, ioaddr1=0x1f0, ioaddr2=0x3f0, irq=14
13 | ata0-master: type=disk, mode=flat, translation=auto, path="harddisk.img", biosdetect=auto, model="Generic 1234"
14 | ata1: enabled=1, ioaddr1=0x170, ioaddr2=0x370, irq=15
15 | ata2: enabled=0
16 | ata3: enabled=0
17 | parport1: enabled=1, file=""
18 | parport2: enabled=0
19 | com1: enabled=1, mode=null, dev=""
20 | com2: enabled=0
21 | com3: enabled=0
22 | com4: enabled=0
23 | usb_uhci: enabled=0
24 | usb_ohci: enabled=0
25 | i440fxsupport: enabled=1
26 | vga_update_interval: 50000
27 | vga: extension=vbe
28 | cpu: count=1, ips=4000000, reset_on_triple_fault=1, ignore_bad_msrs=1
29 | cpuid: cpuid_limit_winnt=0, mmx=1, sse=sse2, xapic=1, sep=1, aes=0, xsave=0, movbe=0, 1g_pages=0, pcid=0 fsgsbase=0
30 | cpuid: stepping=3, vendor_string="GenuineIntel", brand_string="              Intel(R) Pentium(R) 4 CPU        "
31 | print_timestamps: enabled=0
32 | # no gdb stub
33 | port_e9_hack: enabled=0
34 | text_snapshot_check: enabled=0
35 | private_colormap: enabled=0
36 | clock: sync=none, time0=local
37 | # no cmosimage
38 | ne2k: enabled=0
39 | pnic: enabled=0
40 | sb16: enabled=0
41 | # no loader
42 | log: -
43 | logprefix: %t%e%d
44 | panic: action=ask
45 | error: action=report
46 | info: action=report
47 | debug: action=ignore
48 | pass: action=fatal
49 | keyboard_type: mf
50 | keyboard_serial_delay: 250
51 | keyboard_paste_delay: 100000
52 | keyboard_mapping: enabled=0, map=
53 | user_shortcut: keys=none
54 | mouse: enabled=0, type=ps2, toggle=ctrl+mbutton
55 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2015 Krister Walfridsson
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 
23 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | MOVDBZ_PROG=movdbz-addition.s
 2 | 
 3 | CPPFLAGS=-m32 -std=c99 -ffreestanding
 4 | CFLAGS=-Wall -Wextra -nostdlib -O2
 5 | 
 6 | objects =  loader.o run_movdbz_program.o screen.o set_gdtr.o setup.o
 7 | 
 8 | harddisk.img: buildhddimg/buildhddimg.sh kernel.bin
 9 | 	buildhddimg/buildhddimg.sh
10 | 
11 | kernel.bin: $(objects) linker.ld
12 | 	ld -T linker.ld -m elf_i386  -o $@ $(objects)
13 | 
14 | generated-prog.c: movdbz-as.py $(MOVDBZ_PROG)
15 | 	./movdbz-as.py -o generated-prog.c $(MOVDBZ_PROG)
16 | 
17 | loader.o: loader.S
18 | run_movdbz_program.o: run_movdbz_program.c screen.h setup.h 
19 | screen.o: screen.c screen.h
20 | set_gdtr.o: set_gdtr.S
21 | setup.o: generated-prog.c screen.h setup.c setup.h
22 | 
23 | .PHONY : clean
24 | clean:
25 | 	rm -f *.o *.bin *.img *.log generated-prog.c
26 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Instruction-less computation
 2 | This is an implementation of the ideas in the paper “[The Page-Fault Weird Machine: Lessons in Instruction-less Computation](https://www.usenix.org/conference/woot13/workshop-program/presentation/bangert)” by J. Bangert et al., where it is shown that the IA-32 fault handling mechanism is Turing complete, so you can run programs without executing any CPU instructions!
 3 | 
 4 | I did this implementation to get an understanding of how it works in detail – the paper does not describe all the boring parts needed to get this working, and the [trapcc](https://github.com/jbangert/trapcc) implementation from the paper is IMHO hard to understand (it generates all the page tables etc. by Ruby scripts, and it needs to do global analysis with graph coloring etc. to generate working programs). My implementation tries to be easier to understand by choosing a less efficient instruction encoding that eliminates the need of global analysis, so each instruction can be generated individually.
 5 | 
 6 | I have made a Python assembler that generates some code, but that is only syntactic sugar that is not strictly needed. For example, instructions
 7 | 
 8 | ```
 9 | L5:     movdbz r3, 1024, L7, L7
10 | L7:     movdbz r2, r2, L8, exit
11 | L8:     movdbz r3, r3, L7, L7
12 | ```
13 | 
14 | are generated as the C code
15 | 
16 | ```
17 | gen_movdbz(5, 3, 4, 6, 6);    // L5: movdbz r3, 1024, L7, L7
18 | gen_movdbz(6, 2, 2, 7, -1);   // L7: movdbz r2, r2, L8, exit
19 | gen_movdbz(7, 3, 3, 6, 6);    // L8: movdbz r3, r3, L7, L7
20 | ```
21 | 
22 | and it should be easy to follow how each instruction is generated as page tables etc. The construction is described in two blog posts ([overview](http://kristerw.blogspot.se/2015/08/instruction-less-computation.html) and [technical details](http://kristerw.blogspot.se/2015/08/instruction-less-computation-technical.html)).
23 | 
24 | ### Building and running the software
25 | Building the software is as easy as to run
26 | ```
27 | make
28 | ```
29 | which builds a kernel that you need to run on the bochs emulator (or real hardware). It may be possible to use other emulators, but the paper claims that none implements the correct fault behaviour (but that may have been fixed since the paper was written...).
30 | 
31 | I tested to build on a clean Ubuntu 14.04.3 LTS 64-bit desktop, and you only need to install `bochs-sdl` to be ready to go.
32 | 
33 | There is a bochs configuration file in the repository, so running bochs in the source code directory should use it autimatically.
34 | 
35 | ### Changing the movdbz program
36 | The example movdbz program in this repository can be found in [movdbz-addition.s](movdbz-addition.s), and it implements addition as described in the [blog post](http://kristerw.blogspot.se/2015/08/instruction-less-computation.html). You can change this to your own file by updating the `MOVDBZ_PROG` variable in the [Makefile](Makefile), and updating [run_movdbz_program.c](run_movdbz_program.c) to set up the input/output for your program.
37 | 
38 | ### Assembler syntax
39 | The constructed machine is a "one instruction set computer", so the assembler has only one instruction: `movdbz`.
40 | 
41 | The format of the assembler is
42 | ```
43 | <label>: movdbz <dest_reg|discard> <src_reg|constant> <label zero> <label nonzero>
44 | ```
45 | 
46 | Comments can be added by `;` which discards the rest of the line.
47 | 
48 | The registers are of the form `r0`, `r1`, …. The destination register may be `discard`, which is a special built-in write-only register, and is used when only the side effect of comparing the source with 0 is needed. The source register may be a constant 0-1024 written as decimal or hexadecimal (note that the value is decremented before being written to the destination – that is why 1024 is allowed even though the max register value is 1023). 
49 | 
50 | The labels can be any name `[a-zA-Z][a-zA-Z0-9_]*` that is not `movdbz` or `discard`. There is a built-in label `exit` that switches back to the original x86 task instead of to a task implementing a `movdbz` instruction (i.e. it exits the program).
51 | 
52 | The program starts executing from the first instruction in the file.
53 | 


--------------------------------------------------------------------------------
/buildhddimg/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2012, Julian Bangert
 2 | All rights reserved.
 3 | 
 4 | Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
 5 | 
 6 | Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
 7 | Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
 8 | Neither the name of the <ORGANIZATION> nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
 9 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
10 | 


--------------------------------------------------------------------------------
/buildhddimg/buildhddimg.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 |  
 3 | # This script can be used to quickly test MultiBoot-compliant
 4 | # kernels.
 5 |  
 6 | # ---- begin config params ----
 7 |  
 8 | harddisk_image="harddisk.img"
 9 | qemu_cmdline="qemu -monitor stdio"
10 | kernel_args=""
11 | kernel_binary="kernel.bin"
12 |  
13 | # ----  end config params  ----
14 |  
15 |  
16 | function fail() { echo "$1"; exit 1; }
17 | function prereq() {
18 | 	local c x
19 | 	if [ "$1" = "f" ]; then c=stat;x=file; else c=which;x=program; fi
20 | 	if [ -z "$3" ]; then
21 | 		$c "$2" >/dev/null || fail "$x $2 not found"
22 | 	else
23 | 		$c "$2" >/dev/null || fail "$x $2 (from package $3) not found"
24 | 	fi
25 | }
26 |  
27 | # check prerequisites
28 | prereq x mkfs.vfat dosfstools
29 | prereq x mcopy mtools
30 | prereq x syslinux
31 | prereq f /usr/lib/syslinux/mboot.c32 syslinux
32 |  
33 |  
34 | # create image
35 | dd if=/dev/zero of="$harddisk_image" bs=512 count=8064 # ~4 megabytes
36 |  
37 | # format image
38 | mkfs.vfat "$harddisk_image" || fail "could not format harddisk.img"
39 |  
40 | # install syslinux
41 | syslinux "$harddisk_image" || fail "could not install syslinux"
42 |  
43 | # copy over mboot.c32 (required for Multiboot)
44 | mcopy -i "$harddisk_image" /usr/lib/syslinux/mboot.c32 ::mboot.c32 || fail "could not copy over mboot.c32"
45 |  
46 | # copy over kernel
47 | mcopy -i "$harddisk_image" "$kernel_binary" ::kernel.bin || fail "could not copy over kernel"
48 |  
49 | # create syslinux.cfg
50 | echo '
51 | TIMEOUT 1
52 | DEFAULT mboot.c32 kernel.bin '$kernel_args'
53 | ' | mcopy -i "$harddisk_image" - ::syslinux.cfg
54 |  
55 | 


--------------------------------------------------------------------------------
/linker.ld:
--------------------------------------------------------------------------------
 1 | ENTRY (loader)
 2 | 
 3 | SECTIONS
 4 | {
 5 |     . = 0x00c00000;
 6 | 
 7 |     .text ALIGN (0x1000) :
 8 |     {
 9 |         *(.loader)
10 | 	*(.text)
11 |     }
12 | 
13 |     .rodata ALIGN (0x1000) :
14 |     {
15 |         *(.rodata*)
16 |     }
17 | 
18 |     .data ALIGN (0x1000) :
19 |     {
20 |         *(.data)
21 |     }
22 | 
23 |     .bss :
24 |     {
25 |         sbss = .;
26 |         *(COMMON)
27 |         *(.bss)
28 |         ebss = .;
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/loader.S:
--------------------------------------------------------------------------------
 1 | STACKSIZE = 0x4000
 2 | 
 3 | # Constants for GRUB Multiboot header.
 4 | MODULEALIGN = 1<<0
 5 | MEMINFO = 1<<1
 6 | FLAGS = MODULEALIGN | MEMINFO
 7 | MAGIC = 0x1BADB002
 8 | CHECKSUM = -(MAGIC + FLAGS)
 9 | 
10 | 	.global	loader
11 | 	.section .loader
12 | 
13 | 	.long	MAGIC
14 | 	.long	FLAGS
15 | 	.long	CHECKSUM
16 | loader:
17 | 	mov	$stack+STACKSIZE,%esp
18 | 	call	kmain
19 | 	cli
20 | .Lhang:
21 | 	hlt
22 | 	jmp	.Lhang
23 | 
24 | 	.section .bss
25 | stack:	.zero 	STACKSIZE
26 | 


--------------------------------------------------------------------------------
/movdbz-addition.s:
--------------------------------------------------------------------------------
 1 | ;;; Calculate unsigned addition
 2 | ;;; 
 3 | ;;;   r3 = r0 + r1
 4 | ;;; 
 5 | ;;; where r0, r1, and r2 are clobbered.  The implementation does not do any
 6 | ;;; overflow checking, so the result is actually
 7 | ;;; 
 8 | ;;;   r3 = min(r0 + r1, 1023)
 9 | ;;;
10 | ;;; 
11 | ;;; The machine does only have unsigned subtraction, so we need to calculate
12 | ;;; the addition as
13 | ;;;
14 | ;;;   r3 = MAX_VAL - (MAX_VAL - r0 - r1);
15 | ;;; 
16 | ;;; But the subtraction is only done as decrement by 1, so this is expanded as
17 | ;;;
18 | ;;;   r2 = MAX_VAL;
19 | ;;;   while (r0--)
20 | ;;;     r2--;
21 | ;;;   while (r1--)
22 | ;;;     r2--;
23 | ;;;   r3 = MAX_VAL;
24 | ;;;   while (r2--)
25 | ;;;     r3--;
26 | 
27 | L0:	movdbz r2, 1024, L1, L1
28 | 
29 | L1:	movdbz r0, r0, L2, L3
30 | L2:	movdbz r2, r2, L1, L1
31 | 
32 | L3:	movdbz r1, r1, L4, L5
33 | L4:	movdbz r2, r2, L3, L3
34 | 
35 | L5:	movdbz r3, 1024, L7, L7
36 | 
37 | L7:	movdbz r2, r2, L8, exit
38 | L8:	movdbz r3, r3, L7, L7
39 | 


--------------------------------------------------------------------------------
/movdbz-as.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | 
  3 | import argparse
  4 | import os
  5 | import re
  6 | import sys
  7 | 
  8 | 
  9 | class ParseError(Exception):
 10 |     def __init__(self, line_no, value):
 11 |         self.line_no = line_no
 12 |         self.value = value
 13 | 
 14 | 
 15 | def lex_line(line, line_no):
 16 |     token_exprs = [
 17 |         ('[ \\n\\t]+', None),
 18 |         (';[^\\n]*', None),
 19 |         ('movdbz', 'opcode'),
 20 |         ('r[1-9][0-9]*', 'reg'),
 21 |         ('r0', 'reg'),
 22 |         ('discard', 'reg'),
 23 |         (':', 'reserved'),
 24 |         (',', 'reserved'),
 25 |         ('0x[0-9]+', 'integer'),
 26 |         ('[1-9][0-9]*', 'integer'),
 27 |         ('0', 'integer'),
 28 |         ('[a-zA-Z][a-zA-Z0-9_]*', 'label')]
 29 |     pos = 0
 30 |     tokens = []
 31 |     while pos < len(line):
 32 |         match = None
 33 |         for token_expr in token_exprs:
 34 |             pattern, tag = token_expr
 35 |             regex = re.compile(pattern)
 36 |             match = regex.match(line, pos)
 37 |             if match:
 38 |                 text = match.group(0)
 39 |                 if tag:
 40 |                     token = (tag, text)
 41 |                     tokens.append(token)
 42 |                 break
 43 |         if not match:
 44 |             raise ParseError(line_no, 'Syntax error')
 45 |         pos = match.end(0)
 46 |     return tokens
 47 | 
 48 | 
 49 | def parse_movdbz(tokens, line_no):
 50 |     if len(tokens) != 10:
 51 |         raise ParseError(line_no, 'Syntax error')
 52 |     if (tokens[3][0] != 'reg' or
 53 |             tokens[4][1] != ',' or
 54 |             (tokens[5][0] != 'reg' and tokens[5][0] != 'integer') or
 55 |             tokens[6][1] != ',' or
 56 |             tokens[7][0] != 'label' or
 57 |             tokens[8][1] != ',' or
 58 |             tokens[9][0] != 'label'):
 59 |         raise ParseError(line_no, 'Syntax error')
 60 |     if tokens[5][1] == 'discard':
 61 |         raise ParseError(line_no, 'Invalid input register "discard"')
 62 |     return (line_no, tokens[0][1], tokens[2][1],
 63 |             tokens[3][1], tokens[5][1],
 64 |             tokens[7][1], tokens[9][1])
 65 | 
 66 | 
 67 | def parse_line(tokens, line_no):
 68 |     if len(tokens) < 3:
 69 |         raise ParseError(line_no, "Line must start with 'label: opcode'")
 70 |     if tokens[0][0] != 'label' or tokens[1][1] != ':':
 71 |         raise ParseError(line_no, "Line must start with 'label: opcode'")
 72 |     if tokens[0][1] == 'exit':
 73 |         raise ParseError(line_no, "exit is not a valid label name")
 74 |     if tokens[2][1] == 'movdbz':
 75 |         return parse_movdbz(tokens, line_no)
 76 |     else:
 77 |         raise ParseError(line_no, "Unknown opcode " + tokens[2][1])
 78 | 
 79 | 
 80 | def read_file(stream):
 81 |     insts = []
 82 |     line_no = 0
 83 |     for line in stream:
 84 |         line_no += 1
 85 |         tokens = lex_line(line, line_no)
 86 |         if tokens:
 87 |             inst = parse_line(tokens, line_no)
 88 |             insts.append(inst)
 89 |     return insts
 90 | 
 91 | 
 92 | def allocate_label_numbers(insts):
 93 |     label_nr = 0
 94 |     label_to_nr = {}
 95 |     label_to_nr['exit'] = -1
 96 |     for inst in insts:
 97 |         if inst[1] in label_to_nr:
 98 |             raise ParseError(inst[0], "Label already defined")
 99 |         label_to_nr[inst[1]] = label_nr
100 |         label_nr += 1
101 |     return label_to_nr, label_nr - 1
102 | 
103 | 
104 | def validate_labels(insts, label_to_nr):
105 |     for inst in insts:
106 |         if inst[2] == 'movdbz':
107 |             if inst[5] not in label_to_nr:
108 |                 raise ParseError(inst[0], "Unknown label " + inst[5])
109 |             if inst[6] not in label_to_nr:
110 |                 raise ParseError(inst[0], "Unknown label " + inst[6])
111 | 
112 | 
113 | def get_reg_nr(reg):
114 |     if reg[0] == 'r':
115 |         return int(reg[1:])
116 |     else:
117 |         return -1
118 | 
119 | 
120 | def find_max_reg_nr(insts):
121 |     max_reg_nr = -1
122 |     for inst in insts:
123 |         if inst[2] == 'movdbz':
124 |             max_reg_nr = max(max_reg_nr, get_reg_nr(inst[3]))
125 |             max_reg_nr = max(max_reg_nr, get_reg_nr(inst[4]))
126 |     return max_reg_nr
127 | 
128 | 
129 | def get_int(string):
130 |     if string[0:2] == '0x':
131 |         return int(string, 16)
132 |     else:
133 |         return int(string)
134 | 
135 | 
136 | def find_consts(insts):
137 |     consts = set()
138 |     for inst in insts:
139 |         if inst[2] == 'movdbz':
140 |             if inst[4] != 'discard' and inst[4][0] != 'r':
141 |                 consts.add(get_int(inst[4]))
142 |     return consts
143 | 
144 | 
145 | def allocate_consts(consts, max_reg_nr):
146 |     consts = list(consts)
147 |     consts.sort()
148 |     max_const_reg_nr = max_reg_nr
149 |     const_to_reg_nr = {}
150 |     for const in consts:
151 |         max_const_reg_nr += 1
152 |         const_to_reg_nr[const] = max_const_reg_nr
153 |     return max_const_reg_nr, const_to_reg_nr
154 | 
155 | 
156 | def write_reg(stream, reg, const_to_reg_nr):
157 |     if reg[0] == 'r':
158 |         stream.write(str(get_reg_nr(reg)))
159 |     elif reg == 'discard':
160 |         stream.write("-1")
161 |     else:
162 |         stream.write(str(const_to_reg_nr[get_int(reg)]))
163 | 
164 | 
165 | def write_inst(stream, inst, const_to_reg_nr, label_to_nr):
166 |     stream.write("  gen_movdbz(" + str(label_to_nr[inst[1]]) + ", ")
167 |     write_reg(stream, inst[3], const_to_reg_nr)
168 |     stream.write(", ")
169 |     write_reg(stream, inst[4], const_to_reg_nr)
170 |     stream.write(", " + str(label_to_nr[inst[5]]) + ", " +
171 |                  str(label_to_nr[inst[6]]) + ");")
172 |     stream.write("\t// " + inst[1] + ": movdbz " +
173 |                  inst[3] + ", " + inst[4] + ", " +
174 |                  inst[5] + ", " + inst[6] + "\n")
175 | 
176 | 
177 | def main():
178 |     parser = argparse.ArgumentParser()
179 |     parser.add_argument('filename', help='intput file name')
180 |     parser.add_argument('-o', help='output file name', metavar='filename')
181 | 
182 |     args = parser.parse_args()
183 |     if args.o:
184 |         output_file_name = args.o
185 |     else:
186 |         name, ext = os.path.splitext(args.filename)
187 |         if ext == '.s':
188 |             output_file_name = name + '.c'
189 |         else:
190 |             output_file_name = args.filename + '.c'
191 |         output_file_name = os.path.basename(output_file_name)
192 | 
193 |     try:
194 |         with open(args.filename, 'rb') as stream:
195 |             insts = read_file(stream)
196 |             label_to_nr, max_label_nr = allocate_label_numbers(insts)
197 |             validate_labels(insts, label_to_nr)
198 |             max_reg_nr = find_max_reg_nr(insts)
199 |             consts = find_consts(insts)
200 |             max_const_reg_nr, const_to_reg_nr = allocate_consts(consts, max_reg_nr)
201 |     except ParseError as err:
202 |         sys.stderr.write(os.path.basename(args.filename) + ":" +
203 |                          str(err.line_no) + ": " + err.value + '\n')
204 |         sys.exit(1)
205 | 
206 |     with open(output_file_name, 'w') as stream:
207 |         stream.write("// Generated by 'movdbz-as.py " + args.filename +
208 |                      "'\n\n")
209 |         stream.write("#define FIRST_INST_PAGE " +
210 |                      "(REG_R0_PAGE + " + str(max_const_reg_nr + 1) + ")\n")
211 |         stream.write("#define LAST_INST_PAGE (FIRST_INST_PAGE + " +
212 |                      str(max_label_nr + 1) +
213 |                      " * (PAGES_PER_INST) - 1)\n")
214 |         stream.write("\n")
215 |         stream.write("static void\n")
216 |         stream.write("gen_program(void)\n")
217 |         stream.write("{\n")
218 |         stream.write("  // Registers\n")
219 |         for i in range(max_reg_nr + 1):
220 |             stream.write("  gen_reg(" + str(i) + ", 0);\n")
221 |         stream.write("\n")
222 |         if consts:
223 |             stream.write("  // Constants\n")
224 |             for const in consts:
225 |                 stream.write("  gen_reg(" +
226 |                              str(const_to_reg_nr[const]) + ", " +
227 |                              str(const) + ");\n")
228 |             stream.write("\n")
229 |         stream.write("  // Program\n")
230 | 
231 |         for inst in insts:
232 |             write_inst(stream, inst, const_to_reg_nr, label_to_nr)
233 | 
234 |         stream.write("}\n")
235 | 
236 | if __name__ == '__main__':
237 |     main()
238 | 


--------------------------------------------------------------------------------
/run_movdbz_program.c:
--------------------------------------------------------------------------------
 1 | #include "setup.h"
 2 | #include "screen.h"
 3 | 
 4 | static void
 5 | add(int a, int b)
 6 | {
 7 |   write_reg(0, a);
 8 |   write_reg(1, b);
 9 | 
10 |   printf("Calculate saturated r0 + r1 where r0 = %d and r1 = %d\n",
11 | 	 read_reg(0), read_reg(1));
12 | 
13 |   start_movdbz_program();
14 | 
15 |   printf("Result: r3 = %d\n\n", read_reg(3));
16 | }
17 | 
18 | 
19 | void
20 | run_movdbz_program(void)
21 | {
22 |   add(4, 8);
23 |   add(100, 1);
24 |   add(0, 0);
25 |   add(1000, 1000);
26 | }
27 | 


--------------------------------------------------------------------------------
/screen.c:
--------------------------------------------------------------------------------
  1 | #include "screen.h"
  2 | 
  3 | #define COLOR_BLACK           0
  4 | #define COLOR_BLUE            1
  5 | #define COLOR_GREEN           2
  6 | #define COLOR_CYAN            3
  7 | #define COLOR_RED             4
  8 | #define COLOR_MAGENTA         5
  9 | #define COLOR_BROWN           6
 10 | #define COLOR_LIGHT_GREY      7
 11 | #define COLOR_DARK_GREY       8
 12 | #define COLOR_LIGHT_BLUE      9
 13 | #define COLOR_LIGHT_GREEN    10
 14 | #define COLOR_LIGHT_CYAN     11
 15 | #define COLOR_LIGHT_RED      12
 16 | #define COLOR_LIGHT_MAGENTA  13
 17 | #define COLOR_LIGHT_BROWN    14
 18 | #define COLOR_WHITE          15
 19 | 
 20 | #define COLOR(foreground,background)  ((background) << 4 | (foreground))
 21 | 
 22 | #define NUM_LINES 24
 23 | #define NUM_COLS 80
 24 | 
 25 | static int curr_line;
 26 | static int curr_col;
 27 | 
 28 | 
 29 | static void
 30 | setchar(int line, int col, int c)
 31 | {
 32 |   unsigned char *videoram = (unsigned char *)0xB8000;
 33 |   unsigned int idx = 2 * (line * NUM_COLS + col);
 34 |   videoram[idx] = c;
 35 |   videoram[idx + 1] = COLOR(COLOR_GREEN, COLOR_BLACK);
 36 | }
 37 | 
 38 | 
 39 | static void
 40 | clear_line(int line)
 41 | {
 42 |   for (int col = 0; col < NUM_COLS; col++)
 43 |     setchar(line, col, ' ');
 44 | }
 45 | 
 46 | 
 47 | void
 48 | clear_screen(void)
 49 | {
 50 |   for (int line = 0; line < NUM_LINES; line++)
 51 |     clear_line(line);
 52 |   curr_line = 0;
 53 |   curr_col = 0;
 54 | }
 55 | 
 56 | 
 57 | void *
 58 | memset(void *s, int c, unsigned int n)
 59 | {
 60 |   char *p = s;
 61 |   for (unsigned int i = 0; i < n; i++)
 62 |     *p++ = c;
 63 |   return s;
 64 | }
 65 | 
 66 | 
 67 | static void
 68 | putchar(int c)
 69 | {
 70 |   if (c == '\n')
 71 |     {
 72 |       curr_col = 0;
 73 |       if (++curr_line == NUM_LINES)
 74 | 	curr_line = 0; 
 75 |     }
 76 |   else
 77 |     if (curr_col < NUM_COLS)
 78 |       setchar(curr_line, curr_col++, c);
 79 | }
 80 | 
 81 | 
 82 | static void
 83 | print_string(const char *s)
 84 | {
 85 |   while (*s)
 86 |     putchar(*s++);
 87 | }
 88 | 
 89 | 
 90 | static void
 91 | print_uint_helper(unsigned int u)
 92 | {
 93 |   if (u != 0)
 94 |     {
 95 |       print_uint_helper(u / 10);
 96 |       putchar('0' + u % 10);
 97 |     }
 98 | }
 99 | 
100 | 
101 | static void
102 | print_uint(unsigned int u)
103 | {
104 |   if (u == 0)
105 |     putchar('0');
106 |   else
107 |     print_uint_helper(u);
108 | }
109 | 
110 | 
111 | static void
112 | print_hex(unsigned int u)
113 | {
114 |   for (int i = 7; i >= 0; i--)
115 |     {
116 |       const char *c = "0123456789abcdef";
117 |       putchar(c[(u >> (i * 4)) & 0xf]);
118 |     }
119 | }
120 | 
121 | 
122 | static void
123 | print_HEX(unsigned int u)
124 | {
125 |   for (int i = 7; i >= 0; i--)
126 |     {
127 |       const char *c = "0123456789ABCDEF";
128 |       putchar(c[(u >> (i * 4)) & 0xf]);
129 |     }
130 | }
131 | 
132 | 
133 | static void
134 | print_int(int i)
135 | {
136 |   if (i < 0)
137 |     {
138 |       putchar('-');
139 |       print_uint(-i);
140 |     }
141 |   else
142 |     print_uint(i);
143 | }
144 | 
145 | 
146 | void
147 | printf(const char *fmt, ...)
148 | {
149 |   va_list ap;
150 | 
151 |   va_start(ap, fmt);
152 |   while (*fmt)
153 |     {
154 |       if (*fmt == '%')
155 | 	{
156 | 	  switch (*(++fmt))
157 | 	    {
158 | 	    case 'd':
159 | 	    case 'i':
160 | 	      fmt++;
161 | 	      print_int(va_arg(ap, int));
162 | 	      break;
163 | 	    case 'p':
164 | 	      fmt++;
165 | 	      putchar('0');
166 | 	      putchar('x');
167 | 	      print_hex((unsigned int)va_arg(ap, void *));
168 | 	      break;
169 | 	    case 's':
170 | 	      fmt++;
171 | 	      print_string(va_arg(ap, char *));
172 | 	      break;
173 | 	    case 'u':
174 | 	      fmt++;
175 | 	      print_uint(va_arg(ap, unsigned int));
176 | 	      break;
177 | 	    case 'x':
178 | 	      fmt++;
179 | 	      print_hex(va_arg(ap, unsigned int));
180 | 	      break;
181 | 	    case 'X':
182 | 	      fmt++;
183 | 	      print_HEX(va_arg(ap, unsigned int));
184 | 	      break;
185 | 	    default:
186 | 	      putchar('%');
187 | 	      if (*fmt)
188 | 		putchar(*fmt++);
189 | 	    }
190 | 	}
191 |       else
192 | 	putchar(*fmt++);
193 |     }
194 |   va_end(ap);
195 | }
196 | 


--------------------------------------------------------------------------------
/screen.h:
--------------------------------------------------------------------------------
 1 | #ifndef SCREEN_H
 2 | #define SCREEN_H
 3 | 
 4 | #include <stdarg.h>
 5 | 
 6 | void *memset(void *s, int c, unsigned int n);
 7 | void printf(const char *fmt, ...);
 8 | 
 9 | void clear_screen(void);
10 | 
11 | #endif
12 | 


--------------------------------------------------------------------------------
/set_gdtr.S:
--------------------------------------------------------------------------------
 1 | 	.global	set_gdtr
 2 | 	.section .text
 3 | 
 4 | set_gdtr:
 5 | 	sub	$0x10,%esp
 6 | 	mov	0x18(%esp),%eax
 7 | 	mov	%ax,0xa(%esp)
 8 | 	mov	0x14(%esp),%eax
 9 | 	mov	%eax,0xc(%esp)
10 | 	lgdtl	0xa(%esp)
11 | 	add	$0x10,%esp
12 | 	ljmp	$0x8,$.Lreload_cs	# 0x08 points at the new code selector
13 | .Lreload_cs:
14 | 	mov	$0x10,%ax		# 0x10 points at the new data selector
15 | 	mov	%eax,%ds
16 | 	mov	%eax,%es
17 | 	mov	%eax,%fs
18 | 	mov	%eax,%gs
19 | 	mov	%eax,%ss
20 | 	mov	$0x18,%ax
21 | 	ltr	%ax
22 | 	ret
23 | 


--------------------------------------------------------------------------------
/setup.c:
--------------------------------------------------------------------------------
  1 | #include "setup.h"
  2 | #include "screen.h"
  3 | 
  4 | /* The address space is split into sections that are spread out so
  5 |  * that each is allocated using separate page table (i.e. all start
  6 |  * at a multiple of 0x00400000).  */
  7 | #define STACK_ADDRESS       0x00000000
  8 | #define INST_ADDRESS        0x00400000
  9 | #define X86_BASE_ADDRESS    0x00c00000
 10 | #define GDT_ADDRESS         0x01800000
 11 | #define X86_PD_ADDRESS      0x07c00000
 12 | #define PROG_BASE_ADDR      0x08000000
 13 | 
 14 | /* The IDT is a part of the instruction, and is mapped as the first page
 15 |  * in the instruction range. */
 16 | #define IDT_ADDRESS         (INST_ADDRESS)
 17 | 
 18 | 
 19 | /* Page number for the first page in the movdbz program, and translation
 20 |  * to virtual addresses for the program's pages.
 21 |  *
 22 |  * This address range use direct mapping, so the translation is trivial. */
 23 | #define PROG_BASE_PAGE ((PROG_BASE_ADDR) >> 12)
 24 | #define PROGPAGE2VIRT(x) ((unsigned int *)((PROG_BASE_ADDR) + ((x) << 12)))
 25 | 
 26 | 
 27 | /* The movdbz binary starts with 12 pages containing
 28 |  * - Stack PT and a page for the actual stack.
 29 |  * - The GTD PT and four pages for the GDT.
 30 |  * - An initial partial instruction whose PD is used when calling the
 31 |  *   first instruction in the movdbz program.
 32 |  * - A register (initialized to 1) used as input to all internal NOP
 33 |  *   instructions.
 34 |  * - A register used as output to all internal NOPs (and for 'discard'
 35 |  *   register in the assembler.
 36 |  *
 37 |  * This is followed by the registers, constants (which are read-only
 38 |  * registers initialized with the constant's value + 1), and the
 39 |  * instructions.  */
 40 | #define STACK_PAGE           0
 41 | #define STACK_PT_PAGE        1
 42 | #define GTD_PT_PAGE          2
 43 | #define GDT_PAGE0            3
 44 | #define GDT_PAGE1            4
 45 | #define GDT_PAGE2            5
 46 | #define GDT_PAGE3            6
 47 | #define INIT_0               7  // PD
 48 | #define INIT_1               8  // PT for INST_ADDRESS
 49 | #define INIT_2               9  // INST
 50 | #define REG_CONST_ONE_PAGE  10  // Must be (REG_R0_PAGE - 2).
 51 | #define REG_DISCARD_PAGE    11  // Must be (REG_R0_PAGE - 1).
 52 | #define REG_R0_PAGE         12
 53 | 
 54 | /* Each instruction is encoded in four pages.  */
 55 | #define PAGES_PER_INST       4
 56 | #define PD_OFF               0
 57 | #define INST_PT_OFF          1
 58 | #define INST_OFF             2
 59 | #define IDT_OFF              3
 60 | 
 61 | /* The register numbers for the two special registers (i.e. the two registers
 62 |  * before r0).  */
 63 | #define REG_DISCARD         -1
 64 | #define REG_CONSTANT_ONE    -2
 65 | 
 66 | 
 67 | static void gen_reg(int, unsigned int);
 68 | static void gen_movdbz(int, int, int, int, int);
 69 | 
 70 | #include "generated-prog.c"
 71 | 
 72 | 
 73 | static unsigned int x86_tss[26];
 74 | extern void set_gdtr(unsigned int base_addr, unsigned short table_limit);
 75 | 
 76 | 
 77 | #define PG_P  0x001 // Present (i.e. all other ignored if this is not set)
 78 | #define PG_W  0x002 // Write enable
 79 | #define PG_PS 0x080 // 4MB pages if CR4.PSE=1, ignored if CR4.PSE=0
 80 | 
 81 | 
 82 | static void
 83 | write_cr0(unsigned int data)
 84 | {
 85 |   __asm __volatile("movl %0,%%cr0" : : "r" (data) : "memory");
 86 | }
 87 | 
 88 | 
 89 | static unsigned int
 90 | read_cr0(void)
 91 | {
 92 |   unsigned int data;
 93 |   __asm __volatile("movl %%cr0,%0" : "=r" (data));
 94 |   return data;
 95 | }
 96 | 
 97 | 
 98 | static void
 99 | write_cr3(unsigned int data)
100 | {
101 |   __asm __volatile("movl %0,%%cr3" : : "r" (data) : "memory");
102 | }
103 | 
104 | 
105 | static unsigned int
106 | read_eflags(void)
107 | {
108 |   unsigned int data;
109 |   __asm __volatile("pushf\npop %0" : "=r" (data));
110 |   return data;
111 | }
112 | 
113 | 
114 | static void
115 | write_cr4(unsigned int data)
116 | {
117 |   __asm __volatile("movl %0,%%cr4" : : "r" (data) : "memory");
118 | }
119 | 
120 | 
121 | static unsigned int
122 | read_cr4(void)
123 | {
124 |   unsigned int data;
125 |   __asm __volatile("movl %%cr4,%0" : "=r" (data));
126 |   return data;
127 | }
128 | 
129 | 
130 | static void
131 | set_idtr(unsigned int base_addr, unsigned short table_limit)
132 | {
133 |   struct __attribute__((__packed__))
134 |   {
135 |     unsigned short table_limit;
136 |     unsigned int base_addr;
137 |   } idtr;
138 |   idtr.table_limit = table_limit;
139 |   idtr.base_addr = base_addr;
140 |   __asm __volatile("lidtl %0" : : "m" (idtr) : "memory");
141 | }
142 | 
143 | 
144 | static void
145 | init_paging(void)
146 | {
147 |   unsigned int *pde = (unsigned int *)X86_PD_ADDRESS;
148 |   for (int i = 0; i < 512; i++)
149 |     pde[i] = PG_P | PG_PS | PG_W | (i << 22);  // Direct mapping.
150 |   write_cr3(X86_PD_ADDRESS);
151 |   write_cr4(read_cr4() | 0x10);
152 |   write_cr0(read_cr0() | (1 << 31));
153 | }
154 | 
155 | 
156 | /* Encode a segment descriptor. */
157 | static void
158 | encode_seg_descr(
159 |     unsigned int *p,
160 |     unsigned int type,
161 |     unsigned int g,
162 |     unsigned int base,
163 |     unsigned int limit)
164 | {
165 |   p[0] = ((base & 0xffff) << 16) | (limit & 0xffff);
166 |   p[1] = ((base & 0xff000000)
167 | 	  | 0x00400000 | (g << 23) | (limit & 0x000f0000)
168 | 	  | (type << 8)
169 | 	  | ((base & 0x00ff0000) >> 16));
170 | }
171 | 
172 | 
173 | static void
174 | init_gdt(unsigned int *gdt)
175 | {
176 |   memset(gdt, 0, 4096 * 4);
177 |   encode_seg_descr(&gdt[2], 0x9A, 1, 0, 0xfffff);  // code 0x08
178 |   encode_seg_descr(&gdt[4], 0x92, 1, 0, 0xfffff);  // data 0x10
179 |   encode_seg_descr(&gdt[6], 0x89, 0, (unsigned int)x86_tss, 0x67);  // TSS 0x18
180 |   encode_seg_descr(&gdt[0x7fe], 0x89, 0, 0x40ffd0, 0x67);
181 |   encode_seg_descr(&gdt[0xbfe], 0x89, 0, 0x41ffd0, 0x67);
182 |   encode_seg_descr(&gdt[0xffe], 0x89, 0, 0x42ffd0, 0x67);
183 | }
184 | 
185 | 
186 | static void
187 | init_tss(void)
188 | {
189 |   x86_tss[7] = X86_PD_ADDRESS;
190 | }
191 | 
192 | 
193 | unsigned int
194 | read_reg(unsigned int reg_nr)
195 | {
196 |   unsigned int val = *(PROGPAGE2VIRT(reg_nr + REG_R0_PAGE) + 2);
197 |   return val >> 2;
198 | }
199 | 
200 | 
201 | void
202 | write_reg(unsigned int reg_nr, unsigned int val)
203 | {
204 |   *(PROGPAGE2VIRT(reg_nr + REG_R0_PAGE) + 2) = val << 2;
205 | }
206 | 
207 | 
208 | /* Populate the register page (i.e. the last part of the TSS).  */
209 | static void
210 | gen_reg(int reg_nr, unsigned int value)
211 | {
212 |   unsigned int *p = PROGPAGE2VIRT(REG_R0_PAGE + reg_nr);
213 |   p[ 2] = value << 2; // ESP
214 |   p[ 6] = 0x10;  // ES
215 |   p[ 7] = 0x08;  // CS
216 |   p[ 8] = 0x10;  // SS
217 |   p[ 9] = 0x10;  // DS
218 |   p[10] = 0x10;  // FS
219 |   p[11] = 0x10;  // GS
220 |   p[12] = 0;  // LDT Segment Selector
221 | }
222 | 
223 | 
224 | static void
225 | generate_pagetable(
226 |     unsigned int pd_page)
227 | {
228 |   unsigned int *pde_ptr = PROGPAGE2VIRT(pd_page);
229 | 
230 |   /* Map stack at 0x00000000. */
231 |   unsigned int *p0 = PROGPAGE2VIRT(STACK_PT_PAGE);
232 |   p0[0] = PG_P | PG_W | ((PROG_BASE_PAGE + STACK_PAGE) << 12);
233 |   pde_ptr[0] = PG_P | PG_W | ((PROG_BASE_PAGE + STACK_PT_PAGE) << 12);
234 | 
235 |   /* Map the current instruction (including IDT) at 0x00400000. */
236 |   unsigned int *p1 = PROGPAGE2VIRT(pd_page + INST_PT_OFF);
237 |   p1[0] = PG_P | PG_W | ((PROG_BASE_PAGE + pd_page + IDT_OFF) << 12);
238 |   pde_ptr[1] = PG_P | PG_W | ((PROG_BASE_PAGE + pd_page + INST_PT_OFF) << 12);
239 | 
240 |   /* Map the memory used for the x86 at 0x00c00000. */
241 |   pde_ptr[3] = PG_P | PG_PS | PG_W | (3 << 22);
242 | 
243 |   /* Map the GDT on four consecutive pages at 0x01800000. */
244 |   unsigned int *p6 = PROGPAGE2VIRT(GTD_PT_PAGE);
245 |   for (int i = 0; i < 4; i++)
246 |     p6[i] = PG_P | PG_W | ((PROG_BASE_PAGE + GDT_PAGE0 + i) << 12);
247 |   pde_ptr[6] = PG_P | PG_W | ((PROG_BASE_PAGE + GTD_PT_PAGE) << 12);
248 | }
249 | 
250 | 
251 | static unsigned int
252 | inst_to_tss_seg_descr(
253 |     int inst_nr)
254 | {
255 |   if (inst_nr < 0)
256 |     return 0x18;
257 |   else
258 |     switch (inst_nr % 3)
259 |       {
260 |       case 0:
261 | 	return 0x1ff8;
262 |       case 1:
263 | 	return 0x2ff8;
264 |       default:
265 | 	return 0x3ff8;
266 |       }
267 | }
268 | 
269 | 
270 | static unsigned int
271 | inst_to_tss_addr(
272 |     int inst_nr)
273 | {
274 |   switch (inst_nr % 3)
275 |     {
276 |     case 0:
277 |       return INST_ADDRESS + 0x0ffd0;
278 |     case 1:
279 |       return INST_ADDRESS + 0x1ffd0;
280 |     default:
281 |       return INST_ADDRESS + 0x2ffd0;
282 |     }
283 | }
284 | 
285 | 
286 | /* Populate the IDT with the destination instructions. */
287 | static void
288 | generate_idt_page(
289 |     unsigned int pd_page,
290 |     int dest1_inst_nr,
291 |     int dest2_inst_nr)
292 | {
293 |   unsigned int *p = PROGPAGE2VIRT(pd_page + IDT_OFF);
294 |   unsigned int tss_seg_selector1 = inst_to_tss_seg_descr(dest1_inst_nr);
295 |   unsigned int tss_seg_selector2 = inst_to_tss_seg_descr(dest2_inst_nr);
296 | 
297 |   /* #DF - Double Fault */
298 |   p[16] = tss_seg_selector2 << 16;
299 |   p[17] = 0xe500;  /* Task gate present,
300 | 		      DPL (Descriptor Privilege Level) = 3
301 | 		      (i.e. application privilege level) */
302 | 
303 |   /* #PF - Page Fault */
304 |   p[28] = tss_seg_selector1 << 16;
305 |   p[29] = 0xe500;
306 | }
307 | 
308 | 
309 | /* Populate the instruction page (i.e. the first part of the "source TSS"). */
310 | static void
311 | generate_inst_page(
312 |     unsigned int pd_page,
313 |     int inst_nr)
314 | {
315 |   unsigned int *p = PROGPAGE2VIRT(pd_page + INST_OFF);
316 |   unsigned int tss_addr = inst_to_tss_addr(inst_nr);
317 |   p[1019] = (PROG_BASE_PAGE + pd_page) << 12;  /* CR3 */
318 |   p[1020] = 0xfffefff;  /* EIP */
319 |   p[1021] = read_eflags();  /* EFLAGS */
320 |   encode_seg_descr(&p[1022], 137, 0, tss_addr, 0x67);  /* EAX and EDX */
321 | }
322 | 
323 | 
324 | /* Map the "destination TSS" (GDT page and destination register) into the
325 |  * address space. */
326 | static void
327 | map_dest_tss(
328 |     unsigned int pd_page,
329 |     int inst_nr,
330 |     int reg_nr)
331 | {
332 |   unsigned int *p1 = PROGPAGE2VIRT(pd_page + INST_PT_OFF);
333 |   unsigned int tss_addr = inst_to_tss_addr(inst_nr);
334 |   unsigned int seg_descr = inst_to_tss_seg_descr(inst_nr);
335 | 
336 |   p1[((tss_addr & 0x003ff000) >> 12)]
337 |     = PG_P | PG_W | ((PROG_BASE_PAGE + GDT_PAGE0 + (seg_descr >> 12)) << 12);
338 |   p1[((tss_addr & 0x003ff000) >> 12) + 1]
339 |     = PG_P | PG_W | ((PROG_BASE_PAGE + REG_R0_PAGE + reg_nr) << 12);
340 | }
341 | 
342 | 
343 | /* Map the "source TSS" (instruction page and source register) into the
344 |  * address space. */
345 | static void
346 | map_src_tss(
347 |     unsigned int pd_page,
348 |     int inst_nr,
349 |     int reg_nr)
350 | {
351 |   unsigned int *p1 = PROGPAGE2VIRT(pd_page + INST_PT_OFF);
352 |   unsigned int tss_addr = inst_to_tss_addr(inst_nr);
353 |   unsigned int inst_off = inst_nr * PAGES_PER_INST + INST_OFF;
354 | 
355 |   p1[((tss_addr & 0x003ff000) >> 12)]
356 |     = PG_P | PG_W | ((PROG_BASE_PAGE + FIRST_INST_PAGE + inst_off) << 12);
357 |   p1[((tss_addr & 0x003ff000) >> 12) + 1]
358 |     = PG_P | PG_W | ((PROG_BASE_PAGE + REG_R0_PAGE + reg_nr) << 12);
359 | }
360 | 
361 | 
362 | /* Generate one instruction.  */
363 | static void
364 | gen_inst(
365 |     int inst_nr,
366 |     int dest1_inst_nr,
367 |     int dest2_inst_nr,
368 |     int dest_reg,
369 |     int dest1_input_reg,
370 |     int dest2_input_reg)
371 | {
372 |   unsigned int pd_page = FIRST_INST_PAGE + inst_nr * PAGES_PER_INST + PD_OFF;
373 |   generate_pagetable(pd_page);
374 |   generate_idt_page(pd_page, dest1_inst_nr, dest2_inst_nr);
375 |   generate_inst_page(pd_page, inst_nr);
376 |   map_dest_tss(pd_page, inst_nr, dest_reg);
377 |   if (dest1_inst_nr >= 0)
378 |     map_src_tss(pd_page, dest1_inst_nr, dest1_input_reg);
379 |   if (dest2_inst_nr >= 0)
380 |     map_src_tss(pd_page, dest2_inst_nr, dest2_input_reg);
381 | }
382 | 
383 | 
384 | /* Generate one movdbz assembler instruction.  */
385 | static void
386 | gen_movdbz(
387 |     int asminst_nr,
388 |     int dest_reg,
389 |     int source_reg,
390 |     int asmdest1_nr,
391 |     int asmdest2_nr)
392 | {
393 |   /* The movdbz assembler instruction is implemented as three real
394 |    * instructions; two NOP instructions followed by an instruction doing
395 |    * the work.  This simplifies the implementation by automatically handling
396 |    * the restrictions of the X86 hardware:
397 |    * - A task cannot switch to itself
398 |    * - There are limited number of GDTs (because of the workaround for the
399 |    *   busy bit), and the GDTs for the instructions and target instructions
400 |    *   must be distinct.
401 |    * - The input register of the instruction need to be encoded in the
402 |    *   predecessor.
403 |    * Adding the NOPs means that we can generate one assembler instruction
404 |    * at a time, without needing to fix up the code for these issues.  */
405 |   gen_inst(asminst_nr * 3, asminst_nr * 3 + 2, asminst_nr * 3 + 2,
406 | 	   REG_DISCARD, source_reg, source_reg);
407 |   gen_inst(asminst_nr * 3 + 1, asminst_nr * 3 + 2, asminst_nr * 3 + 2,
408 | 	   REG_DISCARD, source_reg, source_reg);
409 |   gen_inst(asminst_nr * 3 + 2, asmdest1_nr * 3, asmdest2_nr * 3 + 1,
410 | 	   dest_reg, REG_CONSTANT_ONE, REG_CONSTANT_ONE);
411 | }
412 | 
413 | 
414 | static void
415 | setup_x86(void)
416 | {
417 |   init_paging();   
418 |   init_tss();
419 |   init_gdt((void *)GDT_ADDRESS);
420 |   set_gdtr(GDT_ADDRESS, 0xffff);   // Sets TSS to 0x18
421 |   set_idtr(IDT_ADDRESS, 0x7ff);
422 | }
423 | 
424 | 
425 | static void
426 | setup_movdbz_program(void)
427 | {
428 |   memset(PROGPAGE2VIRT(0), 0, (LAST_INST_PAGE + 1) * 4096);
429 | 
430 |   gen_reg(REG_CONSTANT_ONE,  1);
431 |   gen_reg(REG_DISCARD,  0);
432 | 
433 |   gen_program();
434 | 
435 |   /* Set up an initial page table and inst needed to call the first
436 |    * instruction in the movdbz program.  */
437 |   generate_pagetable(INIT_0);
438 |   map_src_tss(INIT_0, 0, REG_CONSTANT_ONE);
439 | 
440 |   init_gdt(PROGPAGE2VIRT(GDT_PAGE0));
441 | }
442 | 
443 | 
444 | void
445 | start_movdbz_program(void)
446 | {
447 |   write_cr3((PROG_BASE_PAGE + INIT_0) << 12);
448 |   __asm __volatile ("ljmp  $0x1ff8, $0x0;add $4,%%esp" : : : "memory");
449 | }
450 | 
451 | 
452 | void
453 | kmain(void)
454 | {
455 |   clear_screen();
456 |   setup_x86();
457 |   setup_movdbz_program();
458 | 
459 |   run_movdbz_program();
460 | }
461 | 


--------------------------------------------------------------------------------
/setup.h:
--------------------------------------------------------------------------------
 1 | #ifndef SETUP_H
 2 | #define SETUP_H
 3 | 
 4 | void run_movdbz_program(void);
 5 | 
 6 | unsigned int read_reg(unsigned int reg_nr);
 7 | void write_reg(unsigned int reg_nr, unsigned int val);
 8 | 
 9 | void start_movdbz_program(void);
10 | 
11 | #endif
12 | 


--------------------------------------------------------------------------------