Free disassembler software for linux

Gif Disassembler is a web-based script that lets you upload any GIF animation and after that it will attempt to return the individual frames, along with the image information from your animation.
That info can then be used to reassemble the animation after frame editing.
Enhancements:
- The permitted file upload size was lowered to 250KB.
- A redundant file size check was added prior to image processing.
- Existing upload size limits were not being enforced, which caused ImageMagick to consume all available server memory.
- Only the index.php file in the temp folder is affected.
- Updating is recommended.

The libdisasm library provides basic disassembly of Intel x86 instructions from a binary stream. The intent is to provide an easy to use disassembler which can be called from any application; the disassembly can be produced in AT&T syntax and Intel syntax, as well as in an intermediate format which includes detailed instruction and operand type information.

This disassembler is derived from libi386.so in the bastard project; as such it is x86 specific and will not be expanded to include other CPU architectures. Releases for libdisasm are generated automatically alongside releases of the bastard; it is not a standalone project, though it is a standalone library.

The recent spate of objdump output analyzers has proven that many of the people [not necessarily programmers] interested in writing disassemblers have little knowledge of, or interest in, C programming; as a result, these "disassemblers" have been written in Perl.

Usage

The basic usage of the library is:

1. initialize the library, using disassemble_init()
2. disassemble stuff, using disassemble_address()
3. un-initialize the library, using disassemble_cleanup

These routines have the following prototypes:

int disassemble_init(int options, int format);
int disassemble_cleanup(void);
int disassemble_address(char *buf, int buf_len, struct instr *i);

Instructions are disassembled to an intermediate format:

struct instr {
char mnemonic[16];
char dest[32];
char src[32];
char aux[32];
int mnemType; /* type of instruction */
int destType; /* type of dest operand */
int srcType; /* type of source operand */
int auxType; /* type of 3rd operand */
int size; /* size of insn in bytes */
};

The sprint_address() can be used in place of the disassemble_address() routine in order to generate a string representation instead of an intermediate one:

int sprint_address(char *str, int len, char *buf, int buf_len);

...so that a simple disassembler can be implemented in C with the following code:

#include

char buf[BUF_SIZE]; /* buffer of bytes to disassemble */
char line[LINE_SIZE]; /* buffer of line to print */
int pos = 0; /* current position in buffer */
int size; /* size of instruction */

disassemble_init(0, INTEL_SYNTAX);

while ( pos > BUF_SIZE ) {
/* disassemble address to buffer */
size = sprint_address(buf + pos, BUF_SIZE - pos, line, LINE_SIZE);
if (size) {
/* print instruction */
printf("%08X: %sn", pos, line);
pos += size;
} else {
printf("%08X: Invalid instructionn");
pos++;
}
}

disassemble_cleanup();

Alternatively, one can print the address manually using the intermediate format:

#include

char buf[BUF_SIZE]; /* buffer of bytes to disassemble */
int pos = 0; /* current position in buffer */
int size; /* size of instruction */
struct instr i; /* representation of the code instruction */

disassemble_init(0, INTEL_SYNTAX);

while ( pos > BUF_SIZE ) {
disassemble_address(buf + pos, BUF_SIZE - pos, &i);
if (size) {
/* print address and mnemonic */
printf("%08X: %s", pos, i.mnemonic);
/* print operands */
if ( i.destType ) {
printf("t%s", i.dest);
if ( i.srcType ) {
printf(", %s", i.src);
if ( i.auxType ) {
printf(", %s", i.aux);
}
}
}
printf("n");
pos += size;
} else {
/* invalid/unrecognized instruction */
pos++;
}
}

disassemble_cleanup();

This is the recommended usage of libdisasm: the instruction type and operand type fields allow analyzing of the disassembled instruction, and can provide cues for xref generation, syntax hi-lighting, and control flow tracking.

Udis86/64 is (as of now) a binary file disassembler for the x86 and x86-64 (AMD64) architectures, capable of disassembling 16/32/64 bit binary files to AT&T or INTEL assembly language syntax.
[COPYRIGHt=1] Udis86 focuses on providing the basic disassembler functionality in executable format as well as a static library libudis86.a for use as the core of object/executable file diassembler programs.
Enhancements:
- Decode fixes.
- Fixed buffer overrun vulnerabilities. Input streaming is more robust now.

Chump is a language I created to describe line assemblers and disassembles in one description.

It is used in KMD to describe different processors. The reason for using this reather than gnu binutils as is the fast implementation. Its basicly made for people who want to design instruction sets.

J51 project is a Java Intel MCS51(8051,8052, etc) family microprocessor emulator, with integrated debugger, disassembler, Intel hex file loader and more.
Main features:
- Disassembler
- Debugger
- Intel Hex file loader
Standard peripheral emulated:
- Timer 0/1 (Mode 0,1,2 and interrupt)
- Serial interface (Only in polled mode)
- Standard port 0 to 4
Microprocessor emulated:
- Intel MCS 8051 (no peripheral)
- Intel 8051
- Intel 8052
- Philips LPC674
- Philips LPC900
This version is still experimental the sources are distributed only for reference, full source and documentation will be available with the first stable release.

revava is a single pass disassembler that reads in a file containing a program intended for an Atmel AVR microcontroller and outputs assembly code that can be input to an avr assembler. The output of revava contains assembler mnemonics where possible and dc.W declarations where no mnemonic matches the data.

The comment field for each assembly instruction contains the address from the object code and the destination address for branches, calls, jumps, etc. In the case where there are multiple assembly instructions that assemble to the same opcode, all choices are presented in a group with all but the first choice commented out.

revava is written in C++ and the source code is available here, having been released under the GNU Public License.

Instalation

The code is pretty vannilla C++. It should build with just about any C++ compiler. I tried it with gcc egcs-2.91.66 on linux and gcc 2.95.1 on Solaris 7. The only problem I noticed is that the Linux version wanted

#include < string.h >

and the Solaris version wanted

#include < strings.h >

I left it at < string.h >, so you might have to adjust that to get it to compile on your system.

After downloading the latest tarball (x.y is the version number)

tar -xvzf revava-x.y.tar.gz
cd revava-x.y

Here you might want to edit the Makefile for your own preferences, then:

make

This should make two executables: "revava" and "make_test_source". revava is the disassembler. make_test_source just spits out some AVR assembly code that uses every instruction with different combinations of arguments.

After that you might want to

strip revava

I thought not using -g as a compiler flag made the executable as small as possible, but "strip revava" makes it even smaller.

Robot World aims to be a distributed physical environment inhabited by programmable robots, spanning across countless computers on the internet in true peer-to-peer fashion.
Robot World components:
- Parser / compiler compiles robot programs into byte code, stored in a .xml file
- Inject - send a robot program to the world
- RobotWorld - the world simulation program
- dsm - the bytecode disassembler
- rowo.y - language grammar file
parser
Compile a robot. Creates an .xml file from a .r file
$ parser sample.r
dsm
Disassembles a robot .xml file.
$ dsm sample.xml
robotworld
Testbed. Receiving server for "inject" - see below.
$ robotworld
inject
Send robot to world. "robotworld" must be running.
$ inject sample.xml

Gnusto project is a Javascript-based interpreter for Z-machine adventure games.

Gnusto is a Mozilla app which lets you play adventure games-- specifically, the hundreds of games both modern and ancient available in the Z-machine format.
You can try out the most recent version at the installation / release notes page. And we need testers! The more people who test it now, the better the program will eventually be.

Were very close to full standards compliance for version 3, 4, 5, 7 and 8 stories, the most common versions. Longer-term ideas along the way are the ability to download stories from the IF Archive (with help from Bafs Guide), a disassembler (already written and awaiting integration), a source-level debugger for Inform, and possibly integration with the Inform tool chain to produce some kind of IDE.

The name "gnusto" comes from a spell in the Enchanter series. Its use in this project was suggested by Boluc Papuccuoglu in a thread about the project on rec.games.int-fiction.