Machine code: Difference between revisions

For example, the following assembly language program is given for x86 (32 bit) architectures:

 

add EAX, [ESP+8]

 

This would translate into the following opcode bytes:

 

Or in hexadecimal:

 

;Task:

 

We'll execute the following program:

CLC

ADC #$0C

 

 

LDX #$00 ;initialize array offset to 0

 

Array:

 

If you're going to do this in actual programming (which is somewhat common on 8-bit computers for quick interrupt handling), it may be a good idea to know ahead of time the maximum size of your RAM area for machine code and fill it with return statements to avoid crashing.

 

We'll execute the following program:

ADD.B #12,D0

And here is the code that sets it up:

MOVE.L #$103C0007,(A0)+ ;MOVE.B #7,D0

MOVE.L #$D03C000C,(A0)+ ;ADD.B #12,D0

 

CodeArray:

 

=={{header|Action!}}==

DEFINE CLC="$18"

DEFINE JSR="$20"

 

PrintF("%B+%B=%B%E",a,b,s)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Machine_code.png Screenshot from Atari 8-bit computer]

 

=={{header|Applesoft BASIC}}==

 

=={{header|AutoHotkey}}==

 

'''MCode4GCC''' ([http://ahkscript.org/boards/viewtopic.php?f=6&t=4642 Forum Thread] | [https://github.com/joedf/MCode4GCC GitHub]) - An MCode generator using the GCC Compiler.

MsgBox, % DllCall(&Var, "Char",7, "Char",12)

Var := ""

Loop % StrLen(hex) // 2

NumPut("0x" . SubStr(hex, 2 * A_Index - 1, 2), code, A_Index - 1, "Char")

 

=={{header|BBC BASIC}}==

'''Note''' that ''BBC BASIC for Windows'' includes an 80386/80486 assembler as standard!

 

SYS "GlobalAlloc",0,9 TO code%

 

REM Free memory

SYS "GlobalFree",code%

 

=={{header|C}}==

#include <sys/mman.h>

#include <string.h>

printf("%d\n", test(7,12));

return 0;

 

=={{header|COBOL}}==

This solution is a 64-bit adaptation of the task, using the macOS ABI and 64-bit instructions. The assembly code in question is:

 

movq %rsp, %rbp

movl %edi, -0x4(%rbp)

popq %rbp

retq

The 64-bit "wrapper code" used by the PicoLisp and Go implementations have the parameters <code>7</code> and <code>12</code> baked into it, so I opted for a pure 64-bit implementation rather than manipulating the 64-bit stack to support the 32-bit instructions.

IDENTIFICATION DIVISION.

PROGRAM-ID. MC.

 

 

{{out}}

+0000000019

The machine code shown for adding two numbers targets the MOS 65xx/85xx architecture (6502, 6510, etc.) and is given as follows:

 

 

CLC 18 24

ADC $2001 6D 01 20 109 1 32

STA $2002 8D 02 20 141 2 32

 

# The numbers to be added must be poked into locations $2000 and $2001 (8192 and 8193)

No memory management is performed in this example, which would protect the machine code from being overwritten by BASIC. There are more optimal memory locations for the machine code to reside that are not affected by BASIC, however, the locations of such are unique to each model. For example, the range from $C000 to $CFFF (49152 to 53247) on the Commodore 64 is one such ideal location since BASIC memory ends at $9FFF, and there is no overlapping ROM to interfere.

 

15 ml=8192

20 if peek(ml+3)<>173 and peek(ml+12)<>96 then gosub 100

8199 data 109,1,32 :rem adc $2001

8202 data 141,2,32 :rem sta $2002

 

'''Notes about Program'''

 

=={{header|Common Lisp}}==

;; in this code however I chose to demonstrate only the implementation-dependent programs.

 

 

(FFI:FOREIGN-FREE POINTER)

 

=={{header|Cowgol}}==

 

 

# Run machine code at cptr, given two 32-bit arguments,

code[5] := 100;

print_i32(RunCode(&code as [uint8], 7, 12)); # this prints 7*12 = 84

 

{{out}}

 

Generally new operating systems forbid execution of any address unless it's known to contain executable code. This is a basic version that unlike the C entry executes from array memory. This may crash on some operating systems.

/*

mov EAX, [ESP+4]

 

test(7, 12).writeln;

{{out}}

19

order (so they are popped off in right-to-left order).

 

[6] byte add_mc = (

0xC1, /* POP B - get return address */

/* Call the function and print the result */

writeln(add(12, 7))

{{out}}

<pre>19</pre>

address will be emitted. The linker will even adjust these addresses as required.

 

word a, b, c;

/* print the result */

writeln(c);

{{out}}

<pre>19</pre>

 

=={{header|FreeBASIC}}==

Function test (Byval a As Long, Byval b As Long) As Long

Asm

 

Print test(12, 7)

{{out}}

<pre>19</pre>

 

There doesn't appear to be a way to cast a pointer to a native buffer to a Go function pointer so that the machine code can be run directly. I've therefore written a C function to perform this step and embedded it in the program which 'cgo' allows us to do.

 

import "fmt"

C.munmap(buf, C.size_t(le))

C.free(codePtr)

 

{{out}}

{{trans|C}}

Julia cannot execute machine code directly, but can embed C and C++ with the Cxx library.

 

cxx"""

julia_function = @cxx main()

julia_function()

 

=={{header|Kotlin}}==

 

3. There doesn't appear to be a way to cast a pointer to a native buffer to a Kotlin function pointer so that the machine code can be run. I've therefore written a 'one line' C helper function (in mcode.def) to perform this step and compiled it to a library (mcode.klib) so that it can be called from Kotlin code.

---

 

static inline unsigned char runMachineCode(void *code, unsigned char a, unsigned char b) {

return ((unsigned char (*) (unsigned char, unsigned char))code)(a, b);

 

 

import kotlinx.cinterop.*

println("$a + $b = ${if(c >= 0) c.toInt() else c + 256}")

}

 

{{out}}

 

 

Module Checkit {

Buffer DataMem as Long*10

}

CheckIt

 

Using a lambda function with closures two buffers (buffers are objects in M2000 to handle memory blocks). This also add 12 +7 as the task want (but with no pushing to stack, but poke to data buffer)

 

Function MyAdd {

Buffer DataMem as Long*2

UnsingedAdd=MyAdd()

Print UnsingedAdd(12, 7), UnsingedAdd(500, 100)

 

=={{header|Nim}}==

{{trans|C}}

 

let MAP_ANONYMOUS {.importc: "MAP_ANONYMOUS", header: "<sys/mman.h>".}: cint

discard munmap(buf, sizeof(code))

 

 

=={{header|PARI/GP}}==

GP can't peek and poke into memory, but PARI can add in those capabilities via [[#C|C]].

{{trans|C}}

#include <sys/mman.h>

#include <string.h>

pari_printf("%d\n", test(7,12));

return 0;

 

=={{header|Pascal}}==

Tested under Linux with Freepascal 2.6.4-32BIt ( like the Code used )

cdecl doesn't work in Freepascal under Linux 64-bit

{Inspired... program to demonstrate the MMap function. Freepascal docs }

Uses

if fpMUnMap(P,Len)<>0 Then

Halt(fpgeterrno);

;output:

<pre>12+7 = 19</pre>

=={{header|Phix}}==

Phix has a builtin assembler, which makes the specifics of this task "the hard way to do it".

<span style="color: #004080;">atom</span> <span style="color: #000000;">mem</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">allocate</span><span style="color: #0000FF;">(</span><span style="color: #000000;">9</span><span style="color: #0000FF;">)</span>

<span style="color: #000000;">poke</span><span style="color: #0000FF;">(</span><span style="color: #000000;">mem</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">#8B</span><span style="color: #0000FF;">,</span><span style="color: #000000;">#44</span><span style="color: #0000FF;">,</span><span style="color: #000000;">#24</span><span style="color: #0000FF;">,</span><span style="color: #000000;">#04</span><span style="color: #0000FF;">,</span><span style="color: #000000;">#03</span><span style="color: #0000FF;">,</span><span style="color: #000000;">#44</span><span style="color: #0000FF;">,</span><span style="color: #000000;">#24</span><span style="color: #0000FF;">,</span><span style="color: #000000;">#08</span><span style="color: #0000FF;">,</span><span style="color: #000000;">#C3</span><span style="color: #0000FF;">})</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">c_func</span><span style="color: #0000FF;">(</span><span style="color: #000000;">mfunc</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">12</span><span style="color: #0000FF;">,</span><span style="color: #000000;">7</span><span style="color: #0000FF;">})</span>

<span style="color: #000000;">free</span><span style="color: #0000FF;">(</span><span style="color: #000000;">mem</span><span style="color: #0000FF;">)</span>

In Phix the #ilASM statement (which has guards to allow 32/64/WIN/LNX variants) is usually used for inline assembly, for example (but sticking to the task):

<span style="color: #004080;">atom</span> <span style="color: #000000;">mem</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">allocate</span><span style="color: #0000FF;">(</span><span style="color: #000000;">9</span><span style="color: #0000FF;">)</span>

<span style="color: #000000;">poke</span><span style="color: #0000FF;">(</span><span style="color: #000000;">mem</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">#8B</span><span style="color: #0000FF;">,</span><span style="color: #000000;">#44</span><span style="color: #0000FF;">,</span><span style="color: #000000;">#24</span><span style="color: #0000FF;">,</span><span style="color: #000000;">#04</span><span style="color: #0000FF;">,</span><span style="color: #000000;">#03</span><span style="color: #0000FF;">,</span><span style="color: #000000;">#44</span><span style="color: #0000FF;">,</span><span style="color: #000000;">#24</span><span style="color: #0000FF;">,</span><span style="color: #000000;">#08</span><span style="color: #0000FF;">,</span><span style="color: #000000;">#C3</span><span style="color: #0000FF;">})</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">res</span>

<span style="color: #000000;">free</span><span style="color: #0000FF;">(</span><span style="color: #000000;">mem</span><span style="color: #0000FF;">)</span>

Better yet, albeit perhaps deviating somewhat from the task, but adhering in spirit, and unlike the above runnable on both 32 and 64 bit:<br><small>(Were you to produce a list.asm from this, using p -d, it would show the x86 bytes above or the x64 equivalent, using a mix of octal and hex representations)</small>

<span style="color: #004080;">integer</span> <span style="color: #000000;">res</span>

#ilASM{ jmp @f

}

<span style="color: #0000FF;">?</span><span style="color: #000000;">res</span>

In practice I would omit the jmp/labels/call/ret and probably just use registers instead of the stack:

<span style="color: #004080;">integer</span> <span style="color: #000000;">res</span>

#ilASM{

}

<span style="color: #0000FF;">?</span><span style="color: #000000;">res</span>

All four cases output 19

 

The following runs on 64-bit PicoLisp. Therefore we need some glue code to

interface to the task's 32-bit code.

(struct (native "@" "malloc" 'N 39) 'N

# Align

 

# Free memory

Output:

<pre>19</pre>

routines.

 

 

/* 8080 MACHINE CODE TO ADD TWO BYTES:

 

CALL BDOS(0,0); /* EXIT */

 

{{out}}

</font>

 

CompilerError "Code requires a 32-bit processor."

CompilerEndIf

Data.a $8B,$44,$24,$04,$03,$44,$24,$08,$C2,$08,$00

ecode:

 

=={{header|Python}}==

The ctypes module is meant for calling existing native code from Python, but you can get it to execute your own bytes with some tricks. The bulk of the code is spent establishing an executable memory area - once that's done, the actual execution takes just a few lines.

 

import os

from ctypes import c_ubyte, c_int

res = func(7,12)

print(res)

 

=={{header|Quackery}}==

 

=={{header|Racket}}==

 

(require ffi/unsafe)

(function 7 12)

 

 

=={{header|Raku}}==

 

constant PROT_READ = 0x1; #

}

 

 

In the mean time, here is a less desirable approach by writing a wrapper for the C entry, with the 64 bit instructions from PicoLisp ..

{{trans|C}} test.c

#include <stdlib.h>

#include <sys/mman.h>

munmap (buf, sizeof(code));

return c;

mcode.raku

 

# 20200501 Raku programming solution

 

say test 7, 12;

{{out}}<pre>gcc -Wall -fPIC -shared -o LibTest.so test.c

file LibTest.so

This is heavily inspired by https://www.jonathanturner.org/2015/12/building-a-simple-jit-in-rust.html<br />

Hence, only working on Linux (the only other way to disable memory execution protection on other OSes was to use other crates, which kind of defeats the purpose.)

 

#[cfg(all(

println!("Not supported on this platform.");

}

 

=={{header|Scala}}==

This is very Smalltalk dialect specific, and probably not supported on other Smalltalks; in ST/X, where inline C-code can be compiled dynamically, we can define it as:

{{works with|Smalltalk/X}}

 

mapExecutableBytes:size

%}.

self primitiveFailed

 

next, we need the correct code; the following presents the x86 version (but do not expect this code to NOT crash the Smalltalk VM, as the calling convention is certainly wrong..)

code := #[0x8B 0x44 0x24 0x04 0x03 0x44 0x24 0x08 0xC3].

] ifFalse:[

" now call it "

result := func invokeWithArguments:{10 . 20}

With a few more tricks, it is even possible to install that function as a method in a class; but additional code needs to be generated, to assert that the passed data is correctly boxed/unboxed.

 

Using 64-bit glue code since Swift has limited 32-bit support on x86.

 

 

typealias TwoIntsOneInt = @convention(c) (Int, Int) -> Int

 

print(fudge(x: 7, y: 12))

 

=={{header|Tcl}}==

{{trans|C}}

{{libheader|Critcl}}

 

critcl::ccode {

# But now we have our thunk, we can execute arbitrary binary blobs

set code [binary format c* {0x8B 0x44 0x24 0x4 0x3 0x44 0x24 0x8 0xC3}]

Note that it would be more common to put that thunk in its own package (e.g., <code>machineCodeThunk</code>) and then just do something like this:

 

set code [binary format c* {0x8B 0x44 0x24 0x4 0x3 0x44 0x24 0x8 0xC3}]

 

=={{header|Wren}}==

 

However, it is designed for embedding and we can therefore ask the host to do this for us. Here, we use a host program written in C, the language which Wren itself is written in.

class C {

 

var s = m.map { |byte| String.fromByte(byte) }.join()

<br>

We now embed this Wren script in the following C program, compile and run it.

#include <stdio.h>

#include <string.h>

free(script);

return 0;

 

{{out}}

=={{header|X86-64 Assembly}}==

===UASM 2.52===

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; Linux Build:

 

end

 

=={{header|XPL0}}==

This is for the Raspberry Pi's ARM architecture. The opcodes are effectively "poked" by merely loading the program.

char A, B;

[asm { ldrb r0, A

];

 

 

{{out}}

 

=={{header|Z80 Assembly}}==

read "\SrcCPC\winape_macros.asm"

read "\SrcCPC\MemoryMap.asm"

org &1100

read "\SrcCPC\winape_showhex.asm" ;showhex is at &1100 thanks to the org.

 

If you were doing this for real, it's much better to define the opcodes as labels so that you don't need to memorize them. (I really wish assemblers let you use instruction names as aliases for data, but I imagine that would make parsing much more difficult. Oh well.)