Getting Started with x86 » History » Revision 64
Revision 63 (Alexander Kamkin, 04/06/2017 07:32 PM) → Revision 64/87 (Alexander Kamkin, 04/06/2017 07:48 PM)
h1. Getting Started with x86
{{toc}}
h2. Prerequisite
MicroTESK should be [[Installation Guide|installed]].
h2. Demo Specifications
Specifications of the x86 (8086) instruction set architecture (ISA) can be found in "$MICROTESK_HOME/arch/demo/x86/model/x86.nml":http://forge.ispras.ru/projects/microtesk/repository/entry/trunk/microtesk/src/main/arch/demo/x86/model/x86.nml.
Instruction are described in [[nML Language Reference|nML]] by means of the following constructs (_move r16/r16_ is taken as an example):
## the signature
<pre><code class="c">op mov_r16r16 (dst: R16, src: R16)</code></pre>
## the assembly format
<pre><code class="c">syntax = format("mov %s, %s", dst.syntax, src.syntax)</code></pre>
## the binary encoding
<pre><code class="c">image = format("1000101111%s%s", dst.image, src.image)</code></pre>
## the semantics
<pre><code class="c">
action = {
dst = src;
...
}
</code></pre>
To compile the ISA model, run the following command:
<pre>sh $MICROTESK_HOME/bin/compile.sh x86.nml</pre>
h2. Demo Templates
Test templates for the x86 (8086) ISA can be found in "$MICROTESK_HOME/arch/demo/x86/templates":http://forge.ispras.ru/projects/microtesk/repository/entry/trunk/microtesk/src/main/arch/demo/x86/templates.
The directory contains a number of demo templates including the following ones:
{background:#f6fcff}. | "block.rb":http://forge.ispras.ru/projects/microtesk/repository/entry/trunk/microtesk/src/main/arch/demo/x86/templates/block.rb | demonstrates how to use block constructs |
| "block_random.rb":http://forge.ispras.ru/projects/microtesk/repository/entry/trunk/microtesk/src/main/arch/demo/x86/templates/block_random.rb | demonstrates how to create randomized instruction sequences using block constructs |
{background:#f6fcff}. | "euclid.rb":http://forge.ispras.ru/projects/microtesk/repository/entry/trunk/microtesk/src/main/arch/demo/x86/templates/euclid.rb | demonstrates test program simulation to predict the resulting microprocessor state |
| "random.rb":http://forge.ispras.ru/projects/microtesk/repository/entry/trunk/microtesk/src/main/arch/demo/x86/templates/random.rb | demonstrates how to randomize tests by using biases and distributions |
{background:#f6fcff}. | "random_immediate.rb":http://forge.ispras.ru/projects/microtesk/repository/entry/trunk/microtesk/src/main/arch/demo/x86/templates/random_immediate.rb | demonstrates how to randomize immediate values |
| "random_registers.rb":http://forge.ispras.ru/projects/microtesk/repository/entry/trunk/microtesk/src/main/arch/demo/x86/templates/random_registers.rb | demonstrates how to randomize registers (dependencies) |
Test templates are written in "Ruby":http://www.ruby-lang.org extended with specific [[Template_Description_Language|constructs]] (let us look at "block.rb":http://forge.ispras.ru/projects/microtesk/repository/entry/trunk/microtesk/src/main/arch/demo/x86/templates/block.rb):
# the following code includes the "x86_base.rb":http://forge.ispras.ru/projects/microtesk/repository/entry/trunk/microtesk/src/main/arch/demo/x86/templates/x86_base.rb file where a base template @X86BaseTemplate@ is defined and declares a @BlockTemplate@ template: template as a heir of @X86BaseTemplate@:
<pre><code class="ruby">
require_relative ''x86_base''
class BlockTemplate < X86BaseTemplate # BlockTemplate is a heir of @X86BaseTemplate@
</code></pre>
# the following code starts a @run@ method, which is a template entry point:
<pre><code class="ruby"> def run</code></pre>
# the following code produces a single sequence test case consisting of three instructions:
<pre><code class="ruby">
sequence {
mov_r16r16 ax, bx # pre-defined registers
sub_r16r16 cx, dx # fixed registers
add_r16r16 r16(_), r16(_) # registers to be randomized
}.run # launch test generation
</code></pre>
# the following code atomic sequence; works as sequence in this context
<pre><code class="ruby">
atomic {
mov_r16r16 ax, bx
add_r16r16 cx, dx
sub_r16r16 r16(_), r16(_)
}.run
</code></pre>
# produces three sequences test cases each consisting of one instruction: instruction
<pre><code class="ruby">
iterate {
mov_r16r16 ax, bx
sub_r16r16 cx, dx
add_r16r16 r16(_), r16(_)
}.run
</code></pre>
# the following code produces four sequences each test cases consisting of two instructions: instructions (Cartesian product composed in a random order)
<pre><code class="ruby">
block(:combinator => ''product'', :compositor => ''random'') { # (1) produce the Cartesian product of the nested sets of sequences (''product'')
# (2) for each tuple of the product, randomly merge it into one sequence (''random'')
iterate { # produce two single-instruction sequences
sub_r16r16 cx, dx
add_r16r16 ax, bx
}
iterate { # produce two single-instruction sequences
mov_r16r16 ax, bx
sub_r16r16 r16(_), r16(_)
}
}.run
</code></pre>
# merges two sequences in random fashion; atomic sequences are unmodifiable
<pre><code class="ruby">
block(:combinator => ''diagonal'', :compositor => ''random'', :obfuscator => ''random'') {
sequence {
sub_r16r16 bx, ax
or_r16r16 cx, dx
}
atomic {
prologue { comment ''Atomic starts'' }
epilogue { comment ''Atomic ends'' }
and_r16r16 r16(_), r16(_)
}
}.run
</code></pre>
To generate test program(s) from a test template (in our case, from @block.rb@), run the following command:
<pre>sh $MICROTESK_HOME/bin/generate.sh x86 block.rb --code-file-prefix block --code-file-extension s -v</pre>
When generation is finished, the resulting assembly code can be found in @$MICROTESK_HOME@.
To compile "the output file":http://forge.ispras.ru/attachments/download/5127/block_0000.s, run the following commands:
<pre>
nasm -f elf block_0000.s
ld -m i386pe -s -o block_0000 block_0000.o
</pre>
To execute resulted test cases is possible by means of the "online simulator":https://www.tutorialspoint.com/compile_assembly_online.php
!Example_block.png!