Is there any 8086 emulator (free or paid) for Fedora 17? I am learning assembly language using AT&T style.

I have installed QEMU in RHEL for running the assembly programs in ARM. I have successfully installed QEMU and ARM. However, for debugging we are thinking to use GDB. I want to install the **GDB-Multiarch** in RHEL. I have installed GDB and when I run the command **GDB** I am getting the GDB shell successfully. However, I need to use the **GDB-Multiarch** and I am not able to run this command. To successfully run an assembly program, I need to execute the below command. qemu-system-arm -S -s -M versatilepb -daemonize -m 128M -d in_asm,cpu,exec -kernel hello_world.bin ; gdb-multiarch --batch --command=hello_world.gdb In the above command, I am getting the error as gdb-multiarch command as not found. I am really new to this environment and I would appreciate the help.

(This is in the context of x86-64 Linux.) I am trying to write a high-reliability userland executable, and I have total control over the generated assembly. I don't want to rely on automatic stack allocation, so I would like to put the stack in a known location. Suppose I have calculated that my program uses at most 414 bytes of stack space (exactly). Is it safe to allocate 414 bytes in the .bss section and point RSP to the top? I want to ensure that no bytes outside this region are touched by stack management at any point. While I can be sure that *my* program won't write outside the region, I need to make some syscalls (using the syscall instruction), and I think at least some part of the kernel code operates in the calling executable context. Will it smash my stack? Also, interrupts can happen at any point in the program, and the story behind the "Red Zone" seems to suggest that an arbitrarily large region beyond RSP-128 can be written to at will by interrupt handlers, possibly mangling my data. What kinds of guarantees do I have about this behavior?

I was trying to understand Visibility values in ELF file , and I couldn't Understand the difference between STV_HIDDEN and STV_INTERNAL . After some reseach I found that this may be related to how symbols are exported in symbol table , am not sure whether that is correct or not but if some one explain the story behind the difference it will be helpful for me . Possible Duplicate : https://unix.stackexchange.com/questions/472660/what-are-difference-between-the-elf-symbol-visibility-levels But from the answer there I still couldn't get the difference , perhaps more explaination may help me . Thanks

I am trying to build my system from scratch, since I really like the idea of atomicity of each program in unix-like approach, I would like to preserve it as much as possible in my build. Since GNU binutils, in a way, violates this principle, I would like to know if there is just GNU assembler, which wouldn't be dependant on binutils? If not, are there any minimal and performant alternatives to GNU assembler? I know of yasm, but in case there is a better one, I would like to know of it. Thank you in advance.

I know there is a syscall convention but what do you call the calling convention that precedes it that you see when you call to int 80 rather than syscall, like this. mov rax,4 ; system call number (sys_write) mov rbx,1 ; file descriptor (stdout) mov rcx,hello ; message to write mov rdx,12 ; message length int 0x80 ; call kernel I read [here](http://www.int80h.org/bsdasm/#system-calls) that the arguments after rdx are esi, edi, ebp (or for x64 rsi, rdi, rbp), I don't see it documented in [Wikipedia's page for calling conventions](https://en.wikipedia.org/wiki/X86_calling_conventions) , but [int80h](http://www.int80h.org/bsdasm/#system-calls) seems to indicate that Windows also uses this convention? What is this conventioned named. Where in the Linux Kernel source can I see it defined? And, where is the table that resolves rax to the procedures when you call int 0x80? For syscall, sys_write is rax=1

You might have read about the backdoor that was released with the xz command (versions 5.6.0 and 5.6.1). A malevolent committer gained the trust of his maintainer, and achieved to insert at build time some code that [is targeting sshd and creates a backdoor](https://gist.github.com/thesamesam/223949d5a074ebc3dce9ee78baad9e27) . Other .o files of any Linux distribution can be also affected with the same kind of backdoor. What a malevolent committer has successfully done here, he can have done it elsewhere. And maybe years ago... How should the designers of a Linux distribution, if they are willing to to wipe out such backdoor, should proceed to find any corrupted executable of this kind (made by a diverted build process)? At this moment, the ways I see are: 1. to check every build process of every Linux command created: it's a lot of git repository to check, I think 2. but also, disassemble every existing .o file and have a look to their assembly code, to see if it's coherent with what that executable is supposed to do. What other ways should they use to hunt down this backdoor everywhere it can be?

# Looking for a simple audio interface for Unix For fun, I'm learning x86 assembly language by porting an old game. The trickiest part is finding a way to play simple sounds (square waves, mostly). The game currently expects to be able to write directly to the speaker. How can I most easily play audio in current Unix systems? ## Criteria To be more precise, this is what I'm looking for (most important criteria first): 1. Can play a waveform. (8-bit, 8000Hz is fine). 1. Simple enough to call from assembly language. 1. Works on a modern Debian GNU/Linux system without needing root for more than simple package installation. 1. Users will not have to install (m)any libraries or other dependencies. 1. Portable across as many UNIX systems as possible. (Particularly {Net,Free,Open}BSD. I expect Solaris, MacOS, and WSL may have their own ways of doing things.) ### Preferences The code I'm porting is 32-bit x86 assembly language and I'd rather not convert it to 64-bit at this time. Also, the code does not need to link with libc and it would be nice to keep it that way, if possible. ____ #### Research Here are some of the avenues I have researched: - /dev/audio This is what I had hoped would work: I'd just open [/dev/audio](https://man.netbsd.org/audio.4) as a file and write bytes to it. Unfortunately, it appears that the Linux kernel no longer comes with that device by default, so folks would have to install a kernel module (snd-pcm-oss) as root. (Also, although this is a lesser issue, Linux uses the old SunOS semantics and does not allow multiplexing). - Direct speaker access (/dev/tty0, /dev/input/by-path/platform-pcspkr-event-spkr) This is what the game was original written to use. However, writing directly to a PC's builtin speaker requires root to configure and a kernel module (pcspkr) under Linux. Also, it does not work on laptops and other machines that don't even have a PC speaker attached. - ALSA Linux does come with a sound system that is available without a kernel module called the Advanced Linux Sound Architecture (ALSA). Other Unix systems can [emulate it](https://ftp.netbsd.org/pub/pkgsrc/current/pkgsrc/audio/alsa-lib/index.html) , although I'm not sure how well. It requires a lot more setup and although it appears it could be controlled directly through ioctl, in general it needs an external library (alsa-lib). The interface is ugly in pure assembly, but can be done in C. On Linux, ALSA is inherently dynamically linked and also uses dlopen to loads up even more libraries (pulse, pipewire) at runtime depending upon the configuration. This is a problem because the assembly code I'm working on is 32-bit, but most 64-bit boxes won't have 32-bit versions of libalsa, pulse, and pipewire installed. - Pipe to a fork/exec'd program A syscall to pipe(2) could be used to create file descriptors so the game can just send raw data to a program, such as sox's [play](https://manpages.debian.org/bookworm/sox/play.1.en.html) command, executed in a fork. While this has the nice property of pushing the problem of portability onto some other program, I'd rather avoid a runtime dependency on an external program.

I am trying to work my way through Linux kernel code, and in this file there seems to be a full blown bootloader that bios is expected to run. I was under the impression that generally, grub will be in the mbr and then it will somehow invoke the kernel. My questions are: 1. why is there (to the best of my knowledge) a built in bootloader in the kernel? Is this for historical reasons? 2. Can someone explain step by step what happens from pressing the power button to starting the kernel?

Here is my assembly code:

-asm
.section .data
	mystring: .asciz	"Hello world\n"

.section .text
.globl	_start
_start:

pushl	$0
pushl	$mystring
call	printf

pushl	$0
call 	exit

I am trying to assemble and link this code in my 64 bit ubuntu machine **in 32 bit mode**. This code is assembled successfully with this command :

-shell
as -32 demo.s -o demo.o

but when i try to link it with ld command :

-shell
ld -m elf_i386 -s demo.o -o demo -lc

its giving this error :

ld: skipping incompatible /usr/lib/x86_64-linux-gnu/libc.so when searching for -lc
ld: skipping incompatible /usr/lib/x86_64-linux-gnu/libc.a when searching for -lc
ld: cannot find -lc: No such file or directory
ld: skipping incompatible /usr/lib/x86_64-linux-gnu/libc.so when searching for -lc

What should I do for this? This is my libc.so locations:

libcjson.so.1 (libc6,x86-64) => /lib/x86_64-linux-gnu/libcjson.so.1
	libc.so.6 (libc6,x86-64) => /lib/x86_64-linux-gnu/libc.so.6
	libc.so.6 (libc6) => /lib/i386-linux-gnu/libc.so.6

so i've been playing with perf and assembly i have the following program:

.intel_syntax noprefix

.global _start
_start:
  mov cl, 2
  mov ebx, 0b101
  shr ebx, cl
  and bl, 1 
  je do_stuff

  do_stuff:
  mov eax, 1
  mov ebx, 0
  int 0x80

and when I use it with perf -e instructions:u ./shift it shows 9 instructions instead of 8, I could not find why is that. is there any way to find out which is the +1 instruction? is it just one of the program instructions but running in parallel then the cpu retires it? if thats the case how can observe how that works at a lower level? compiling with: as -msyntax=intel -mnaked-reg shift.s -o shift.o && ld shift.o -o shift /proc/sys/kernel/perf_event_paranoid set to -1

The [IBM AIX Documentation](https://www.ibm.com/docs/en/aix/7.3?topic=set-svc-supervisor-call-instruction) for the svc (Supervisor Call) instruction has a note that states > To ensure correct operation, an svc instruction must be preceded by an unconditional branch or a CR instruction. Why is this required?

I would like to write a chess engine for Linux. It will be in pure X64 Assembly language without any C/C++ or any other high level languages external libraries. It will run in full screen text/console/terminal mode. No GUI. It will use Unicode characters to display the chess pieces. I know how to make it in Windows Console API. Which Linux kernel syscalls are relevant to directly access the terminal and to change the font to one that supports Unicode? I obviously researched it but found very little info, mostly for 32 bit with int 0x80 calls.

I have a bootable kernel image, that I had created with MinGW Toolchain's that available for Microsoft Windows 11. The Project is in size tiny, but I would know: "How can I shrink the image, if it grow to pass it on a Floppy Disk." Thanks for Ideas. Edit: You can found a Example OS for this request at my git account: [**paule32**](https://github.com/paule32/JustFunOS_win32/releases/tag/Release)

I want to start learning assembly language, but all the googling didn't make any sense. I got some Exec format error and even used wine which is not good for understanding. So I wonder if anyone can tell what command line assembler will do on x86-64 architecture and probably some hello world example for Linux?

I am currently implementing a C runtime library for the Arm64 platform, and I am unsure which assumptions I can make about the environment at the precise point that the application is executed (what the ELF file has defined as the entry point). With environment, I am primarily referring to the stack setup and the cpu registers. I was able to piece together information by looking at the kernel source code, but not everything. My question is: Is the calling convention into applications documented and/or standardized? I am looking for something equivalent to Arm64 Base Procedure Call Standard for example. *I am posting this in the Unix & Linux Stack Exchange, because I am interested in Linix specifically, and I assume an operating system may perform this call in anyway it defines as long as all executables conform.*

I notice when using

-d

, it outputs the assembly (in either Intel syntax or AT&T syntax), the binary opcode encodings and the address numbers. In my case, I just want the disassembler to just output the AT&T assembly as it is irritating to remove the first 18-24 characters (yeah, didn’t count that) to copy assembly from one object file to an assembly file.

Is it possible, in Linux, to write an x86 assembly program that print a character to the screen (standard output) **without** the use of any system call? I think that it is not possible because, in x86 assembly, the input/output operations are priviledge, so it's impossible to run that operation if the CPU is not in RING 0.

when i run

-c *.c

, it runs:-

gcc -c file1.c -o file1.o
gcc -c file2.c -o file2.o
gcc -c file3.c -o file3.o
...

but

*.s

runs:-

as file1.s -o a.out
as file2.s -o a.out
as file3.s -o a.out
...

by default, gcc replaces the only the file extension while compiling into an object file but gnu as sets the default file output as a.out. how to make gnu as to replace .s into .o while assembling?

I'm using [this script](https://hg.pushbx.org/ecm/wwwecm.scr/file/dfb37b7cdb68/update-dl-wwwecm) to build and package some applications I developed. Full content of the script is listed at the end. It is called by this crontab entry: 50 23 * * * nice $HOME/update-dl-wwwecm $HOME | tee -a $HOME/build-dl-wwwecm/log For debugging I copied the script to a test directory ~/test/20211101/t/ and edited it slightly. (As in removing some of the packages that are hardcoded at the end of the script.) I also manually mkdir build-dl-wwwecm and mkdir webrepos in this test directory and hg clone to get the following repos into the webrepos subdirectory: 1. [lmacros macro collection](https://hg.pushbx.org/ecm/lmacros/) (This one is required to build any of the others. And it should be listed as the first repo to update.) 2. [lClock application](https://hg.pushbx.org/ecm/lclock/) 3. [KEEPHOOK utility](https://hg.pushbx.org/ecm/keephook/) 4. [SHUFHOOK utility](https://hg.pushbx.org/ecm/shufhook/) Next I added an "every minute" line to my crontab like this: * * * * * nice $HOME/test/20211101/t/update-dl-wwwecm $HOME/test/20211101/t | tee -a $HOME/test/20211101/t/build-dl-wwwecm/log The update script checks for incoming commits from the repos in the webrepos subdirectory. It then pulls the new commits and for every mak.sh script file found in the build directory tree it changes into that file's directory and runs that file. This is [the full mak.sh for KEEPHOOK](https://hg.pushbx.org/ecm/keephook/file/c3ead749bea9/mak.sh) :

#! /bin/bash
nasm -I ../lmacros/ -f bin transien.asm -l keephook.lst -o keephook.com "$@"

Now what I observe is if I call the update script myself logged in as my user (via ssh, running bash within screen, connected to the server with the ConnectBot app), then everything works as expected. The commands go like this: hg -R build-dl-wwwecm/keephook strip tip (so the update script will find a new commit to pull) then ./update-dl-wwwecm "$PWD" (to actually do the update, with the parameter for BASE specified as the test directory). However, if the same script is called from the crontab then one thing is different: NASM appears to delete and then not create the output file keephook.com - although it does create a keephook.lst listing file that appears to be complete. No error or warning is found in the log file. All other applications are built fine. Why is that and how to fix it? --- Here's the full update script:

#! /bin/bash

# Usage of the works is permitted provided that this
# instrument is retained with the works, so that any entity
# that uses the works is notified of this instrument.
#
# DISCLAIMER: THE WORKS ARE WITHOUT WARRANTY.

BASE="$1"
if [[ -z "$BASE" ]]
then
  echo "Error: No base specified." >&2
  exit 1
fi
SDIR="$BASE"/webrepos
[[ -n "$2" ]] && BASE="$2"
BDIR="$BASE"/build-dl-wwwecm
TDIR="$BASE"/wwwecm/download
ODIR="$BASE"/wwwecm/download/old

[[ ! -d "$BDIR" ]] && mkdir -p "$BDIR"
[[ ! -d "$TDIR" ]] && mkdir -p "$TDIR"
[[ ! -d "$ODIR" ]] && mkdir -p "$ODIR"

function update() {
	# $1 = path below BDIR
	# $2 = "-r" if there is a branch
	# $3 = branch name if there is a branch
  if [[ ! -d "$BDIR"/"$1" ]]
  then
    hg init "$BDIR"/"$1"
  fi
  cd "$BDIR"/"$1"
  if var="$(hg incoming "$SDIR"/"$1" $2 $3)"; then
    echo "$var"
    hg pull "$SDIR"/"$1" $2 $3 && hg up $3
    find . -name mak.sh -print0 | \
      ONE="$1" xargs -r0 bash -c \
        'for file; do echo === "$ONE"/"$file"; (cd "${file%/*}"; "./${file##*/}"); done' scriptlet
    if [[ -f "$TDIR"/"$1".zip ]]
    then
      [[ ! -d "$ODIR"/"$1" ]] && mkdir -p "$ODIR"/"$1"
      datestamp="$(date -r "$TDIR"/"$1".zip +%Y%m%d)"
      echo === mv --backup=numbered "$TDIR"/"$1".zip "$ODIR"/"$1"/"$datestamp".zip
      mv --backup=numbered "$TDIR"/"$1".zip "$ODIR"/"$1"/"$datestamp".zip
    fi
    echo === zipping "$1"
    7za a -mm=deflate -mx=9 -tzip "$TDIR"/"$1".zip *
  fi
}

update lmacros
update keephook
update shufhook
update rxansi
update lclock
update seekext
update tsr
update fdapm
update renumber
touch "$BDIR"/lastrun