Liste der Hallo-Welt-Programme / Assembler



This Liste von Hallo- Welt-Programm von Assemblersprachen Enthält kleine Computer – Programm, sterben auf Einfache Weise zeigen, Welche Anweisungen für ein Vollständiges Programm in Einer Programmiersprachebenötigt Werden.

Zweck

Aufgaben dieses Hello-Welt-Programm ist, Der Text Hallo Welt! auf eine einfache Art. Programm auszugeben. Weitere Programme sind verfügbar:

  • Höhere Programmiersprachen
  • Sonstige

x86-CPU

→ Hauptartikel : X86-Prozessor und Prozessor

DOS (COM-Datei), MASM, TASM

→ Hauptartikel : DOS , MASM und TASM
Siehe auch : COM-Datei
.MODEL Winzige
.CONST
 HW DB " Hallo Welt ! $ "
.CODE
.org 100 h
Start:
 MOV DX , OFFSET DGROUP : HW
 MOV AH , 09 H
 INT 21 H
 rechts
als Start

DOS (EXE-Datei), MASM, TASM

Siehe auch : EXE
.MODEL Kleine
.STACK 100 h
.CONST
 HW DB " Hallo Welt ! $ "
.CODE
starten:
 MOV AX , @ Daten
 MOV DS , AX
 MOV DX , OFFSET DGROUP : HW
 MOV AH , 09 H
 INT 21 H
 MOV AH , 4 Ch
 INT 21 H
als Start

DOS, FASM

→ Hauptartikel : FASM
'' ' FASM Beispiel für das Schreiben von 16 - Bit DOS .COM Programm ' ''
; Compiler: "FASM HELLO.ASM HELLO.COM"
 org $ 100
 use16
 mov ah , 9
 mov dx , hallo
 int $ 21 ; Textausgabe
 mov ah , $ 4C
 int $ 21 ; Programm gesendet
hallo db ' Hallo Welt !!! $ '

Windows, FASM

; Ausgabe in messageBox (ohne Titel) mit OK - Taste
schließen ' win32ax.inc '
.CODE
 starten:
 aufrufen MessageBoxA , HWND_DESKTOP , Text , "" , MB_OK
 aufrufen Exit - Prozess , 0
.END starten
.data
Text: db " Hallo Welt ! " , 0

Linux

→ Hauptartikel : Linux

AT & T Syntax

# Kompilieren mit
# "als -o hallo.o hallo.s; ld -o hallo hallo.o"
 .section .data
s: .String ! "Hallo Welt \ N"
 .section .text
 .globl _start
_start:
 MOVL $ 4 , % eax # sYSCALL ID 4 (= sys_write)
 MOVL $ 1 , % ebx # Ausgabe-Dateideskriptor stdout (= 1)
 MOVL $ s , % ECX # Adresse der Erste Zeichen der Zeichenkette
 MOVL 12 $ , % EDX # Länge der Zeichenkette (12 Zeichen )
 int $ 0x80 # Softwareinterrupt 0x80 Mikron syscall (write (1, s, 12)) auszuführen
 MOVL $ 1 , % eax # Syscall - ID 1 (= sys_exit)
 MOVL $ 0 , % ebx # Rückgabewert 0 (= alles in Ordnung)
 int $ 0x80 # Softwareinterrupt 0x80 Mikron Syscall (exit (0)) auszuführen

Intel Syntax

; Befehl zum Assemblen: nasm -felf hallo.s
; && ld -o hallo hallo.o
 abschnitt daten
hallo db " Hallo Welt ! " , 0xa
len equ $ -hello
 abschnitt text
 global _start
_start:
 mov eax , 4 ; write (stdout, hallo, LEN)
 mov ebx , 1
 mov ECX , hallo
 MOV EDX , Landkreis
 int 80 h
 mov eax , 1 ; Ausgang (0)
 mov ebx , 0
 int 80 h

x86-CPU, FreeBSD, Intel Syntax

→ Hauptartikel : FreeBSD
 Abschnitt .data
 hallo_world db ' Hallo Welt ! ' , 0x0A
 hello_world_len EQU $ - hello_world
 Abschnitt .text
 ausrichten 4
 sys:
 int 0x80
 ret
 global _start
 _start:
 Push hello_world_len
 schieben hello_world
 Push 1
 mov eax , 4
 Aufruf sys
 Push 0
 mov eax , 1
 Aufruf sys

PowerPC CPU, Linux

→ Hauptartikel : PowerPC
 # Kompilieren mit "gcc -nostdlib -s hallo.s"
 .section .rodata
 .align 2
 .s:
 System.String "Hallo Welt! \ N"
 .section ".text"
 .align 2
 .globl _start
 _start:
 li 0 , 4 # SYS_write
 li 3 , 1 # fd = 1 (stdout)
 lis 4 ,. s @ Für # buf = .s
 lassen 4 . s @ 1 ( 4 )
 li 5 , 12 # len = 12
 sc # syscall
 li 0 , 1 # SYS_exit
 li 3 , 0 # returncode = 0
 sc # syscall

MMIX, MMIXAL

→ Hauptartikel : MMIX
 String BYTE "Hallo Welt!" , # A , 0 % auszugebende Zeichenkette ( # A ist ein Zeilenumbruch ,
 % 0 schliesst Zeichenkette ab sterben)
 Haupt AGG $ 255 , String % Adresse wo Zeichenkette in Register $ 255 AbleGet
TRAP 0 , fputs , stdout % Zeichenkette , auf di e mit Registrieren $ 255
 % wird, nach '' StdOut '' auslassen (Systemaufruf)
 TRAP 0 , Halt , 0 % Prozess beenden

680×0-CPU, Amiga

→ Hauptartikel : Motorola 68000 und Amiga
 ; Getestet mit ASM-One V1.01
 move.l 4 .w , a6
 lea dosn ( pc ), a1
 JSR - 408 ( a6 ) ; OldOpenLibrary
 move.l d0 , a6
 lea s ( pc ), a0
 move.l a0 , d1
 jsr - 948 ( a6 ) ; PutStr
 move.l a6 , a1
 move.l 4 .w , a6
 jsr - 414 (a6 ) ; Schließen Bibliothek
 moveq # 0, d0
 rts
 dosn: DC.B " dos.library " , 0
 s: DC.B " Hallo Welt ! " , 10 , 0

PA-RISC CPU, HP-UX

→ Hauptartikel : PA-RISC und HP-UX
 ; Kompiliert und getestet mit
 ; " Wie hallo.s; ld hallo.o / usr / ccs / lib / crt0"
 ; unter HP-UX 11.0 Auf einer HP9000 / L2000
 .level 1 .1
 .space $ TEXT $
 .SUBSPA $ LIT $ , ACCESS = 0x2c
 s System.String " Hallo Welt ! \ x0a "
 .space $ TEXT $
 .SUBSPA $ CODE $ , ACCESS = 0x2c , CODE_ONLY
 .EXPORT _start , ENTRY , PRIV_LEV = 3
 .EXPORT __errno
 .EXPORT __sys_atexit
 _start
 __errno
 __sys_atexit
 ldil L ' 0xC0000000 , % R18
 LDI 4 , % r22 ; SYS_write
 ldi 1 , % r26 ; fd = stdout
 ldil LR ' s , % r4
 LDO RR ' s ( % r4 ), % R25 ; buf = s
 be , l 4 ( % sr7 , % r18 ) ; Syscall
 ldi 12 , % r24 ; len = 12 (Verzweigungsverzögerungs-Slot)
 ldi 1 , % r22 ; Sys_exit
 Anfrage , L 4 ( % SR7 , % R18 ) ; Syscall
 ldi 0 , % r26 ; Rückkehrcode = 0 (Verzweigungsverzögerungs-Slot)

SPARC CPU, Linux

Siehe auch : SPARC-Architektur
; Kompilieren mit "als -o hallo.o hallo.s; ld -o Hallo hallo.o"
.section .data
hallo_str:
 .asciz "Hallo Welt! \ N"
 .align 4 ; Speicher muss ausgerichtet sein, dass wir spucken mit ld darauf zugreifen können
hallo_str_len :
 .word . - Hallo_str ; Länge der Zeichenkette (12 Zeichen)
.section .text
.global _start
_start:
 Set 4 , % g1 ; Syscall ID 4 (= __NR_write)
 Set 1 , % o0 ; Ausgabe Dateideskriptor STDOUT (= 1)
 set hallo_str , % o1 ; Adresse des ersten Zeichens der Zeichenkette
 set hallo_str_len , % l0 ; Die Stack-Adressen, zu denen die Länge der Zeichenkette gehört, befinden sich in lokaler 0 Last
 ld [ % l0 ], % o2 ; Der Wert auf der lokalen 0 Segel in 2
 Schubladen t 0x110 ; Software-Interrupt 0x110 über Syscall (write (1, hallo_str, hello_str_len)) aussetzen
 setzen 1 , % g1 ; Syscall ID 1 (= __NR_exit)
 setzt 0 , % o0 ; Rückgabewert 0 (= alles in
 Ordnung ) t 0x110 ; Software-Interrupt 0x110 über Syscall (Ausgang (0)) auszuführ

Assemblersprache (Jasmin)

→ Hauptartikel : Jasmin (Programmiersprache)
; HelloWorld.j
.bytecode 50 .0
.source HelloWorld.java
.class- öffentliche Hello World
.Super java / lang / Object
beträgt.Verfahren public < init > () V
 .limit Stapel 1
 .limit Einheimischen ein
 aload_0
 invokespecial java / lang / Objekt / < init > () V
 return
.END Methode
.Verfahren public static Haupt ([Ljava / lang / String ;)
 V.limit stack 2
 .limit Einheimische 1
 getstatic java / lang / System / aus Ljava / io / PrintStream ;
 ldc " Hallo Welt ! "
 invokevirtual java / io / DruckStream / println ( Ljava / lang / String ;) V
 return
.end- Methode

MIPS-32 mit erweitertem Befehlssatz

Siehe auch : MIPS-Architektur
# Emulation mit 'spim -f hw.asm'
.data
Hello World: .asciiz "Hallo Welt! \ N" # 'z' in ASCIIZ für Null-Termini Erbsen-string
.text
Haupt:
lassen $ a0 , Hello World # Ladung Adresse von Hello World
li $ v0 , 4 # print_string
syscall
li $ v0 , 10 # Betriebssystem Ausfahrt Routine
syscall

ARM Armv7l, Linux

→ Hauptartikel : ARM-Architektur # ARMv7_.282004.29
.text
.global _start
_start:
 / * Drucken * /
 mov r2 , $ 11
 LDR r1 , = hw
 mov r0 , $ 1
 mov r7 , $ 4
 svc $ 0
 / * Ausgang * /
 sub r0 , r0 , r0
 mov r7 , $ 1
 svc $ 0
.data
hw:
.ascii "Hallo Welt \ n"

IBM Mainframe ASSEMBLER [ Verarbeitung | Quelltextverarbeitung ]

→ Hauptartikel : Z_Systems # Die_CPU
Hallow CSECT
*
*********************************************** ******************
* Assembler PROGRAMMIERBARES FUER IBM MAIN FRAME MIT
* STANDARD REGISTERSICHERUNG , LAUFFAEHIG UNTER
* THE Gaeng Klassisches Mainframe - Betriebssystem
* ( AUCH jedenfall Z / OS UND Z / VM UND DEREN VORLAEUFERN )
******************************************** *********************
*
 UNTER VERWENDUNG Hallow , 15 BASISADR = ENTRY POINT
 STM 14 , 12 , 12 ( 13 ) REGISTER sichern
 LA 2 , SAVE - Bereich NEUE SPEICHERN AREA EINSTELLEN
 ST 2 , 8 ( 13 ) VORWAERTSVERKETTUNG SICHERN AREAS
 ST 13 , 4 ( 2 ) RUECKWAERTSVERKETTUNG SICHERN AREAS
 LR 13 , 2 NEUE SICHERN AREA NACH REG 13
*
 OPEN ( Ausgabe , OUTPUT ) DD : SYSPRINT Aufmachen
 PUT Ausgabe , BUFFER Version : HALLO WELT !
 SCHLIESSEN Ausgabe DD : SYSPRINT ZUMA CHEN
*
 LA 13 , 4 ( 13 ) ALTE SPEICHERN AREA WIEDER EINSTELLEN
 LM 14 , 12 , 12 ( 13 ) REGISTER ZURUECKLADEN
 XR 15 , 15 RETCODE AUF NULL
 BR 14 RUECKSPRUNG
*
SAVE - Bereich DS 18 F SAVE - AREA
*
Ausgabe DCB DDie = PS , MACRF = PM , DDNAME = SYSPRINT , RECFM = FBA , LRECL = 133
*
BUFFER DC CL133 ' HALLO WELT ! '
*
 END Hallow

Der Programmcode wird über feste Kantegrenzen erreicht:

  • Spalte 1-8 = Feldbezeichnung
  • Spalte 9 = „-“ Zeile ist fortsetzung der vorherigen Zeile; „*“ Kommentar Segel
  • in Spalte 10 Start = Befehlscode
  • in Spalte 16 start = Befehlsparameter, dahinter (nach Leerstelle) optional gläubiger Kommentar
  • Spalte 72 = „-“ wird in der nächsten Zeile fortgesetzt, für lange Literale verwendet
  • Spalte 73-80 = Kennung / lfd Nummerierung (optional)

6502-CPU, C64

→ Hauptartikel : C64
; Hallo , Welt für 6502 CPU (C64)
, verwendet Assembler: win2c64
 LDY # $ 00; init Schleifenzähler
L0
 LDA L1 , Y , ein Byte des Text laden
 Beq L2 , wenn Null -> Ende
 JSR $ FFD2 ; rufen CHROUT
 Iny ; inc Schleifenzähler
 JMP L0 , dank Paul Nicholls
L1
 .Byte "Hallo Welt" , 0
L2
 RTS

8048-CPU, Philips G7000

→ Hauptartikel : Intel 8048
 Aufruf starten gfxoff ; Schalten Sie die Grafiken aus
 mov r0 , # vdc_char0; Startzeichen
 mov r3 , # 20h; x Position
 mov r4 , # 20h; y Position
 mov r2 , # 0Bh; Länge
 mov r1 , #hellostr & 0FFh; die zu druckende Zeichenfolge
 ; in der gleichen Seite muß
Schleife mov a , r1 ; bekomme Zeiger
 movp a , @ a ; erhalten char
 mov r5 , a ; in zwei richtige Register
 inc r1 ; Vorzurücken pointer
 mov r6 , #col_chr_white; Farbe
 Anruf printchar ; ausdrucken
 DJNZ r2 , loop ; es wieder tun
 rufen gfxon ; Mal sehen was geschrieben ist.
Stop jmp stop ; Das ist alles
hellostr db 1 Dh , 12 h , 0 Eh , 0 Eh , 17 h , 0 Ch
 db 11 h , 17 h, 13 h , 0 Eh , 1 Ah

Z80-CPU, Amstrad CPC

1 ld hl , Text ; Adresse oder Text in hl
2 Schleife : ld a , ( hl ) ; Akku laden nach Inhalt bei Adresse in hl
3 cp 0 ; vergleichen mit Null
4 rechts z ; Rückgabe wenn Null
5 Aufruf & bb5a ; ansonsten char in akku
6 inc hl drucken ; hl = hl +1
7 Jr. Schleife ; relativer Sprung zu Schleife
8 text : db " Hallo Welt ! " , 0 ; Text mit 0 als Endmarke