Machine code: Difference between revisions
Added S-BASIC example
Puppydrum64 (talk | contribs) m (rearranged omits in alphanumeric order) |
(Added S-BASIC example) |
||
| (17 intermediate revisions by 11 users not shown) | |||
Line 4:
For example, the following assembly language program is given for x86 (32 bit) architectures:
<
add EAX, [ESP+8]
ret</
This would translate into the following opcode bytes:
<syntaxhighlight lang="text">139 68 36 4 3 68 36 8 195</
Or in hexadecimal:
<syntaxhighlight lang="text">8B 44 24 04 03 44 24 08 C3</
;Task:
Line 22:
* Perform any clean up actions that are appropriate for your chosen language (free the pointer or memory allocations, etc.)
=={{header|6502 Assembly}}==
We'll execute the following program:
<syntaxhighlight lang="6502asm">LDA #$07
CLC
ADC #$0C
RTS</syntaxhighlight>
<syntaxhighlight lang="6502asm">main:
LDX #$00 ;initialize array offset to 0
LDA #$A9 ;LDA #immediate
STA Array,x ;store at offset 0
INX ;next offset
LDA #$07 ;first parameter
STA Array,x ;store at offset 1
INX ;next offset
LDA #$18 ;CLC
STA Array,x ;store at offset 2
INX ;next offset
LDA #$69 ;ADC #immediate
STA Array,x ;store at offset 3
INX ;next offset
LDA #$0C ;second parameter
STA Array,x ;store at offset 4
INX ;next offset
LDA #$60 ;RTS
STA Array,x ;store at offset 5
JMP Array ;assuming we used a JSR to get to main, the RTS at the end of this RAM will return us back to BASIC.
;if array is directly underneath this statement, we can actually omit this JMP entirely
;and execution will simply fall through to the array.
Array:
byte 0,0,0,0,0,0</syntaxhighlight>
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.
=={{header|68000 Assembly}}==
We'll execute the following program:
<syntaxhighlight lang="68000devpac">MOVE.B #7,D0
ADD.B #12,D0
RTS</syntaxhighlight>
And here is the code that sets it up:
<syntaxhighlight lang="68000devpac">LEA CodeArray,A0
MOVE.L #$103C0007,(A0)+ ;MOVE.B #7,D0
MOVE.L #$D03C000C,(A0)+ ;ADD.B #12,D0
MOVE.W #$4E75,(A0)+ ;RTS
JSR CodeArray
JMP $ ;halt the cpu, we're done.
CodeArray:
DS.B 16 ;16 bytes of padding (this is assumed to be RAM)</syntaxhighlight>
=={{header|Action!}}==
<syntaxhighlight lang="action!">DEFINE ADC="$6D"
DEFINE CLC="$18"
DEFINE JSR="$20"
DEFINE LDA="$AD"
DEFINE RTS="$60"
DEFINE STA="$8D"
PROC Main()
BYTE ARRAY buf(20)
BYTE a=[19],b=[37],s
CARD addr
addr=buf
Poke(addr,CLC) addr==+1
Poke(addr,LDA) addr==+1
PokeC(addr,@a) addr==+2
Poke(addr,ADC) addr==+1
PokeC(addr,@b) addr==+2
Poke(addr,STA) addr==+1
PokeC(addr,@s) addr==+2
Poke(addr,RTS) addr==+1
[JSR buf] ;run the machine code stored on buf
PrintF("%B+%B=%B%E",a,b,s)
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Machine_code.png Screenshot from Atari 8-bit computer]
<pre>
19+37=56
</pre>
=={{header|Applesoft BASIC}}==
<syntaxhighlight lang="text">POKE768,169:POKE770,24:POKE771,105:POKE773,133:POKE775,96:POKE774,235:POKE769,7:POKE772,12:CALL768:?PEEK(235)</syntaxhighlight>
=={{header|AutoHotkey}}==
Line 27 ⟶ 126:
'''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 := ""
Line 37 ⟶ 136:
Loop % StrLen(hex) // 2
NumPut("0x" . SubStr(hex, 2 * A_Index - 1, 2), code, A_Index - 1, "Char")
}</
=={{header|BBC BASIC}}==
Line 43 ⟶ 142:
'''Note''' that ''BBC BASIC for Windows'' includes an 80386/80486 assembler as standard!
<
SYS "GlobalAlloc",0,9 TO code%
Line 60 ⟶ 159:
REM Free memory
SYS "GlobalFree",code%
END</
=={{header|C}}==
<
#include <sys/mman.h>
#include <string.h>
Line 93 ⟶ 192:
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)
Line 108 ⟶ 207:
popq %rbp
retq
</syntaxhighlight>
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.
Line 183 ⟶ 282:
</syntaxhighlight>
{{out}}
+0000000019
Line 193 ⟶ 292:
The machine code shown for adding two numbers targets the MOS 65xx/85xx architecture (6502, 6510, etc.) and is given as follows:
<syntaxhighlight lang="text">Assembly Hexadecimal Decimal
CLC 18 24
Line 199 ⟶ 298:
ADC $2001 6D 01 20 109 1 32
STA $2002 8D 02 20 141 2 32
RTS 60 96</
# The numbers to be added must be poked into locations $2000 and $2001 (8192 and 8193)
Line 211 ⟶ 310:
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
Line 230 ⟶ 329:
8199 data 109,1,32 :rem adc $2001
8202 data 141,2,32 :rem sta $2002
8205 data 96 :rem rts</
'''Notes about Program'''
Line 248 ⟶ 347:
=={{header|Common Lisp}}==
<
;; in this code however I chose to demonstrate only the implementation-dependent programs.
Line 304 ⟶ 403:
(FFI:FOREIGN-FREE POINTER)
</syntaxhighlight>
=={{header|Cowgol}}==
<
# Run machine code at cptr, given two 32-bit arguments,
Line 339 ⟶ 438:
code[5] := 100;
print_i32(RunCode(&code as [uint8], 7, 12)); # this prints 7*12 = 84
print_nl();</
{{out}}
Line 349 ⟶ 448:
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]
Line 365 ⟶ 464:
test(7, 12).writeln;
}</
{{out}}
19
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
With the "Asm" directive, you can insert machine language directly into Delphi code. If you use the assembly language instructions, you don't have to know the opcode numbers. However, it you really want to insert raw binary values, you can use directives like "db" and "dw" to insert raw values.
<syntaxhighlight lang="Delphi">
function AddNumbers(Num1, Num2: integer): Integer;
{Add two numbers in assembly language}
asm
PUSH EBX
PUSH EDX
MOV ECX,Num1
MOV EDX,Num2
ADD ECX,EDX
MOV Result,ECX
POP EDX
POP EBX
end;
procedure TestAssembly(Memo: TMemo);
var I,J,K: integer;
begin
for I:=1 to 5 do
for J:=1 to 5 do
begin
K:=AddNumbers(I,J);
Memo.Lines.Add(IntToStr(I)+' + '+IntToStr(J)+' = '+IntToStr(K));
end;
end;
</syntaxhighlight>
{{out}}
<pre>
1 + 1 = 2
1 + 2 = 3
1 + 3 = 4
1 + 4 = 5
1 + 5 = 6
2 + 1 = 3
2 + 2 = 4
2 + 3 = 5
2 + 4 = 6
2 + 5 = 7
3 + 1 = 4
3 + 2 = 5
3 + 3 = 6
3 + 4 = 7
3 + 5 = 8
4 + 1 = 5
4 + 2 = 6
4 + 3 = 7
4 + 4 = 8
4 + 5 = 9
5 + 1 = 6
5 + 2 = 7
5 + 3 = 8
5 + 4 = 9
5 + 5 = 10
</pre>
=={{header|Draco}}==
It is possible to call any random area of memory as if it were a function by casting it
to a function of the right type, similar to C. The following example stores the code in
an array. The CP/M version of Draco passes the arguments on the stack in left-to-right
order (so they are popped off in right-to-left order).
<syntaxhighlight lang="draco">/* 8080 machine code in an array */
[6] byte add_mc = (
0xC1, /* POP B - get return address */
0xD1, /* POP D - get second argument */
0xE1, /* POP H - get first argument */
0x19, /* DAD D - add arguments */
0xC5, /* PUSH B - push return address back */
0xC9 /* RET - return */
);
proc nonrec main() void:
/* Declare a function pointer */
type fn = proc(word a, b) word;
fn add;
/* Pretend the array is actually a function */
add := pretend(add_mc, fn);
/* Call the function and print the result */
writeln(add(12, 7))
corp</syntaxhighlight>
{{out}}
<pre>19</pre>
Draco also supports inline machine code directly, using the <code>code()</code>
construct. The machine code is emitted in place during compilation, and cannot
be changed at runtime. It is possible to refer to variables directly, whose
address will be emitted. The linker will even adjust these addresses as required.
<syntaxhighlight lang="draco">proc nonrec main() void:
word a, b, c;
/* assign values to the input variables */
a := 12;
b := 7;
/* inline machine code to add A and B
*
* Note that we have to cast each value to a byte,
* because by default, numeric constants are assumed
* to be 16-bit words, and would be emitted as two
* bytes each.
*
* The intent is for the programmer to define byte
* constants corresponding to opcodes, and write
* "assembly", but that is beyond the scope here. */
code(
make(0x2A, byte), a, /* LHLD a - load var A into HL */
make(0xEB, byte), /* XCHG - put it in DE */
make(0x2A, byte), b, /* LHLD b - load var B into HL */
make(0x19, byte), /* DAD D - add DE to HL */
make(0x22, byte), c /* SHLD c - store the result in var C */
);
/* print the result */
writeln(c);
corp</syntaxhighlight>
{{out}}
<pre>19</pre>
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">'' This is an example for the x86 architecture.
Function test (Byval a As Long, Byval b As Long) As Long
Asm
mov eax, [a]
Add eax, [b]
mov [Function], eax
End Asm
End Function
Print test(12, 7)
Sleep</syntaxhighlight>
{{out}}
<pre>19</pre>
=={{header|Go}}==
Line 377 ⟶ 623:
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"
Line 414 ⟶ 660:
C.munmap(buf, C.size_t(le))
C.free(codePtr)
}</
{{out}}
Line 424 ⟶ 670:
{{trans|C}}
Julia cannot execute machine code directly, but can embed C and C++ with the Cxx library.
<
cxx"""
Line 462 ⟶ 708:
julia_function = @cxx main()
julia_function()
</syntaxhighlight>
=={{header|Kotlin}}==
Line 475 ⟶ 721:
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.*
Line 518 ⟶ 764:
println("$a + $b = ${if(c >= 0) c.toInt() else c + 256}")
}
}</
{{out}}
Line 532 ⟶ 778:
<syntaxhighlight lang="m2000 interpreter">
Module Checkit {
Buffer DataMem as Long*10
Line 584 ⟶ 830:
}
CheckIt
</syntaxhighlight>
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)
<syntaxhighlight lang="m2000 interpreter">
Function MyAdd {
Buffer DataMem as Long*2
Line 631 ⟶ 877:
UnsingedAdd=MyAdd()
Print UnsingedAdd(12, 7), UnsingedAdd(500, 100)
</syntaxhighlight>
=={{header|Nim}}==
{{trans|C}}
<
let MAP_ANONYMOUS {.importc: "MAP_ANONYMOUS", header: "<sys/mman.h>".}: cint
Line 656 ⟶ 902:
discard munmap(buf, sizeof(code))
echo test(7, 12)</
=={{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>
Line 689 ⟶ 935:
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
Line 728 ⟶ 974:
if fpMUnMap(P,Len)<>0 Then
Halt(fpgeterrno);
end.</
;output:
<pre>12+7 = 19</pre>
Line 734 ⟶ 980:
=={{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>
Line 740 ⟶ 986:
<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>
Line 755 ⟶ 1,001:
<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
Line 782 ⟶ 1,028:
}
<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{
Line 800 ⟶ 1,046:
}
<span style="color: #0000FF;">?</span><span style="color: #000000;">res</span>
<!--</
All four cases output 19
Line 806 ⟶ 1,052:
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
Line 838 ⟶ 1,084:
# Free memory
(native "@" "free" NIL P)</
Output:
<pre>19</pre>
Line 851 ⟶ 1,097:
routines.
<
/* 8080 MACHINE CODE TO ADD TWO BYTES:
Line 918 ⟶ 1,164:
CALL BDOS(0,0); /* EXIT */
EOF</
{{out}}
Line 927 ⟶ 1,173:
</font>
<
CompilerError "Code requires a 32-bit processor."
CompilerEndIf
Line 971 ⟶ 1,217:
Data.a $8B,$44,$24,$04,$03,$44,$24,$08,$C2,$08,$00
ecode:
EndDataSection</
=={{header|Python}}==
Line 979 ⟶ 1,225:
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
Line 1,016 ⟶ 1,262:
res = func(7,12)
print(res)
</syntaxhighlight>
=={{header|Quackery}}==
This task is a bit of a stretch, but the Quackery engine is a virtual machine, so technically Quackery is an assembly language.
Specifically the engine is a stack based processor that does not have direct access to RAM; instead a co-processor mediates requests for dynamically allocated memory. More details in the About Quackery section of Quackery's Category page. (Click on the header for this task.)
So, with the limitations that using Hex numbers to indicate opcodes is not possible, and understanding that when a chunk of memory is requested it is addressed by an offset and a reference to the start of the allocated memory (the numerical address of which is not available to the programmer), this is a walkthrough of the process in the Quackery shell.
As it is a stack machine arguments are passed via the data stack, reducing the specified task to a single operation; the MOV is not required. Therefore I have substituted a different specification that requires two operators - it is "add two numbers and negate the result".
Numbers in Quackery are signed BigIntegers; there are no unsigned numbers, so that part of the task is omitted.
Please don't flag this as incorrect - it's the best you'll get.
<pre>/O> ( check that + and negate are operators (i.e. op-codes )
... ' + operator? ' negate operator? and if [ say "true"]
...
true
Stack empty.
/O> ( create a memory block large enough to hold them, )
... ( filled with zeros )
... 0 2 of
...
Stack: [ 0 0 ]
/O> ( poke the + operator into place )
... ' + swap 0 poke
...
Stack: [ + 0 ]
/O> ( poke the negate operator into place )
... ' negate swap 1 poke
...
Stack: [ + negate ]
/O> ( Using the phrase )
... ( )
... ( ' + ' negate join )
... ( )
... ( would be more idiomatic, but )
... ( the task specifies poking. )
Stack: [ + negate ]
/O> ( now put two numbers underneath it on the stack )
... 7 12 rot
...
Stack: 7 12 [ + negate ]
/O> ( and run the machine code )
... do
...
Stack: -19
/O> ( ta-da! )
</pre>
=={{header|Racket}}==
<
(require ffi/unsafe)
Line 1,041 ⟶ 1,350:
(function 7 12)
(scheme-free-code code)</
=={{header|Raku}}==
I don't know how to translate this C line <
<syntaxhighlight lang="raku"
constant PROT_READ = 0x1; #
Line 1,077 ⟶ 1,386:
}
say test 7, 12;</
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>
Line 1,105 ⟶ 1,414:
munmap (buf, sizeof(code));
return c;
}</
mcode.raku
<syntaxhighlight lang="raku"
# 20200501 Raku programming solution
Line 1,118 ⟶ 1,427:
say test 7, 12;
</syntaxhighlight>
{{out}}<pre>gcc -Wall -fPIC -shared -o LibTest.so test.c
file LibTest.so
Line 1,128 ⟶ 1,437:
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(
Line 1,172 ⟶ 1,481:
println!("Not supported on this platform.");
}
</syntaxhighlight>
=={{header|S-BASIC}}==
The target CPUs for the 8-bit CP/M machines which supported S-BASIC
are the 8080 and the Z80. The documented approach to
including machine code is to declare a common array sufficient in
size to hold the machine language routine. The common data area starts
at 011A hex. The byte values for the op codes could either
be directly stashed in the array, as here, or more conveniently in the case
of a longer routine, assembled at a starting address of
011Ah and then overlaid into the compiled S-BASIC program using
the debugger DDT.COM. The machine code would be invoked
using the CALL statement, which takes one of two forms. In the
first, the only argument is the starting address of the machine code.
In the second, used here, four variables following the address are mapped to
the 8080's HL, DE, BC, and A_PSW register pairs.
<syntaxhighlight lang = "BASIC">
$constant CODESIZE = 4 rem - size of our ml routine
$constant ML_LOC = 011AH rem - beginning of common data area
dim common byte ml_code(CODESIZE)
var hl, de, bc, a_psw = integer
comment
The 8080 machine language routine adds two unsigned
8-bit numbers passed as the low-order bytes in the
BC and DE registers, and leaves the result in HL.
end
ml_code(1) = 79H rem MOV A,C
ml_code(2) = 83H rem ADD E
ml_code(3) = 6FH rem MOV L,A
ml_code(4) = 0C9H rem RET
bc = 7 rem first number
de = 12 rem second number
rem - call the routine and display the result (returned in HL)
call (ML_LOC, hl, de, bc, a_psw)
print bc; " plus"; de; " equals"; hl
end
</syntaxhighlight>
{{out}}
<pre>
7 plus 12 equals 19
</pre>
=={{header|Scala}}==
Line 1,181 ⟶ 1,537:
Considered to be more harmful than useful.
=={{header|Scheme}}==
<syntaxhighlight lang="scheme">
#!/usr/bin/env gosh
#| -*- mode: scheme; coding: utf-8; -*- |#
(use c-wrapper)
(use gauche.uvector)
(use gauche.sequence)
(c-load '("sys/mman.h" "string.h"))
;; target architecture is x86_64 aka amd64
;; add 2 ints and return int
;; lea (%rsi,%rdi,1),%eax #x8d #x4 #x3e
;; retq #xc3
(define code #u8(#x8d #x4 #x3e #xc3))
(define buf (mmap 0
(size-of code)
(logior PROT_READ PROT_WRITE PROT_EXEC)
(logior MAP_PRIVATE MAP_ANONYMOUS)
-1
0))
(define (main args)
(memcpy buf code (size-of code))
(print ((cast (c-func-ptr <c-uchar> (list <c-uchar> <c-uchar>)) buf) 7 12))
(munmap buf (size-of code))
0)
</syntaxhighlight>
=={{header|Smalltalk}}==
Line 1,192 ⟶ 1,578:
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
Line 1,208 ⟶ 1,594:
%}.
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:[
Line 1,232 ⟶ 1,618:
" now call it "
result := func invokeWithArguments:{10 . 20}
</syntaxhighlight>
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.
Line 1,242 ⟶ 1,628:
Using 64-bit glue code since Swift has limited 32-bit support on x86.
<
typealias TwoIntsOneInt = @convention(c) (Int, Int) -> Int
Line 1,276 ⟶ 1,662:
print(fudge(x: 7, y: 12))
</syntaxhighlight>
=={{header|Tcl}}==
{{trans|C}}
{{libheader|Critcl}}
<
critcl::ccode {
Line 1,310 ⟶ 1,696:
# 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}]
puts [runMachineCode $code 7 12]</
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}]
puts [runMachineCode $code 7 12]</
=={{header|Wren}}==
Line 1,322 ⟶ 1,708:
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 {
Line 1,341 ⟶ 1,727:
var s = m.map { |byte| String.fromByte(byte) }.join()
System.print("%(a) + %(b) = %(C.runMachineCode(s, a, b))")</
<br>
We now embed this Wren script in the following C program, compile and run it.
<syntaxhighlight lang="c">/* gcc Machine_code.c -o Machine_code -lwren -lm */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
Line 1,370 ⟶ 1,758:
void C_runMachineCode(WrenVM* vm) {
/* unpack arguments passed from Wren */
int
const char *code = wrenGetSlotBytes(vm, 1, &len);
unsigned char a = (unsigned char)wrenGetSlotDouble(vm, 2);
unsigned char b = (unsigned char)wrenGetSlotDouble(vm, 3);
/* obtain result */
unsigned char c = rmc_helper(code, a, b,
/* return result to Wren */
Line 1,436 ⟶ 1,824:
WrenVM* vm = wrenNewVM(&config);
const char* module = "main";
const char* fileName = "
char *script = readFile(fileName);
WrenInterpretResult result = wrenInterpret(vm, module, script);
Line 1,452 ⟶ 1,840:
free(script);
return 0;
}</
{{out}}
Line 1,461 ⟶ 1,849:
=={{header|X86-64 Assembly}}==
===UASM 2.52===
<
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Linux Build:
Line 1,603 ⟶ 1,991:
end
</syntaxhighlight>
=={{header|XPL0}}==
This is for the Raspberry Pi's ARM architecture. The opcodes are effectively "poked" by merely loading the program.
<syntaxhighlight lang="xpl0">func Sum(A, B); \Return sum of A+B
char A, B;
[asm { ldrb r0, A
ldrb r1, B
add r0, r1
strb r0, A
}
return A;
];
IntOut(0, Sum(7, 12))</syntaxhighlight>
{{out}}
<pre>19</pre>
=={{header|Z80 Assembly}}==
<syntaxhighlight lang="z80">;;;;;;;;;;;;;;;;;;; HEADER ;;;;;;;;;;;;;;;;;;;
read "\SrcCPC\winape_macros.asm"
read "\SrcCPC\MemoryMap.asm"
read "\SrcALL\winapeBuildCompat.asm"
read "\SrcALL\lib\z80_opcode_chart.asm"
;;;;;;;;;;;;;;;;;;; PROGRAM ;;;;;;;;;;;;;;;;;;;
org &1000
ld hl,machine_code_area
;assembles the following:
;LD A,7
;ADD 12
;DAA
;CALL SHOWHEX
;RET
ld (hl),&3E ;LD A,nn
inc hl
ld (hl),7
inc hl
ld (hl),&C6 ;ADD nn
inc hl
ld (hl),12
inc hl
ld (hl),&27 ;DAA
inc hl
ld (hl),&CD ;call
inc hl
ld (hl),&00 ;low byte of address of showhex
inc hl
ld (hl),&11 ;high byte of address of showhex
inc hl
ld (hl),&C9 ;RET
;FALLTHROUGH IS INTENTIONAL
machine_code_area:
;0 = nop
byte 0,0,0,0,0,0,0,0
byte 0,0,0,0,0,0,0,0
byte 0,0,0,0,0,0,0,0
byte 0,0,0,0,0,0,0,0
byte 0,0,0,0,0,0,0,0
byte 0,0,0,0,0,0,0,0
byte 0,0,0,0,0,0,0,0
byte 0,0,0,0,0,0,0,0
org &1100
read "\SrcCPC\winape_showhex.asm" ;showhex is at &1100 thanks to the org.
read "\SrcCPC\winape_stringop.asm"</syntaxhighlight>
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.)
{{omit from|360 Assembly}}
{{omit from|8080 Assembly}}
{{omit from|8086 Assembly}}
{{omit from|AArch64 Assembly}}
{{omit from|ARM Assembly}}
{{omit from|Mathematica}}
{{omit from|MIPS Assembly}}
{{omit from|x86 Assembly}}
| |||