Code/Data Logger

(Taken from the FCEUXD readme.txt)

Introduction

The Code/Data Logger makes it *much* easier to reverse-engineer NES ROMs.  The idea behind it is that a normal NES disassembler cannot distinguish between code (which is executed) and data (which is read). The Code/Data logger keeps track of what is executed and what is read while the game is played, and stores this information in a .cdl file, which is essentially a mask that tells which bytes in the ROM are code and which are data. The file can then be used in conjunction with a suitable disassembler (which I plan to make) to disassemble only the actual game code, resulting in a much cleaner source code, with code and data properly separated.

Using the Code/Data Logger

The Code/Data Logger keeps track of every byte in the ROM and records whether it's code (is executed) or data (is read). In the future, I hope to combine this with a suitable disassembler that will disassemble only bytes marked as "code", in order to generate near-perfect source code (provided you play through the game several times, very thoroughly, to ensure everything gets logged). In order to get that feature to work, I need to get the Address Label Logger working, in order to create all the labels.

But right now, it is very useful for finding specific code and data by using it with the Trace Logger (see above for instructions on doing this).  Furthermore, while it is running, the Hex Editor will color-code bytes depending on whether they were logged as code or data. And it can also be used to create a stripped NES ROM (see below).

Some notes: when you open another .cdl file, it does not clear the current log; instead, it combines it with the information in the file.  This can be useful if you're trying to obtain a complete log, as multiple people can play through the game and keep code/data logs, and then the results can be combined.  But if you would like to actually clear the code/data log, press the "Reset Log" button.

A "stripped" NES ROM is one in which everything that was not logged by the code/data logger is removed. This may be just a novelty feature, however it can be useful because you can view the ROM in a Hex Editor, and you'll see only the parts that were used while playing. Furthermore, you could use it to create a demo ROM by only playing through the parts you would like others to see.

To do so, follow these steps:

1. Open the Code/Data Logger, and press Start to begin logging.

2. Perform a soft and a hard reset while logging, in order to capture the ROM's startup sequence. If you don't do so, you can distribute a save-state file so they will start from within the game.

3. If the game has Save-RAM (e.g. Zelda), you will need to capture the game's Save-RAM initialization routines; you can try to do so by deleting the game's *.sav file and then perform a soft and hard reset (F10, F11) again while logging.

4. Play through whatever levels you want present in the demo. Be sure to perform every move, get every item, etc., so that the code and data necessary for those things are logged. If, for example, you fail to perform some special move, then if someone plays the stripped ROM and attempts to perform that move, the game may very well crash or glitch up.

5. Save the stripped NES ROM.

6. Rejoice, for it is done.

CDL log files are just a mask of the PRG-ROM; that is, they are the same size as the PRG-ROM, and each byte represents the corresponding byte of the PRG-ROM.  The format of each byte is like so (in binary):

               xPdcAADC

               C  = Whether it was accessed as code.

               D  = Whether it was accessed as data.

               AA = Into which ROM bank it was mapped when last accessed:

                       00 = $8000-$9FFF        01 = $A000-$BFFF

                       10 = $C000-$DFFF        11 = $E000-$FFFF

               c  = Whether indirectly accessed as code.

                       (e.g. as the destination of a JMP ($nnnn) instruction)

               d  = Whether indirectly accessed as data.

                       (e.g. as the destination of an LDA ($nn),Y instruction)

               P  = If logged as PCM audio data.

               x  = unused.

CDL files make possible a number of things never before done.  First, a PCM data ripper could be created that scans for data that has the 'P' bit set, in order to find/rip/play every PCM sample in a ROM.  Also, it is possible for someone to make a more intelligent ROM corruptor that only corrupts data (by checking the 'D' bit).  In any case, the Code/Data Logger opens many new possibilities for discovering useful things in games.  Another interesting possibility (which is now partially supported) would be to use the Code/Data Logger on an NSF file to create a stripped NSF. Such an NSF would contain nothing but the relevant subroutines and data required by each tune played; this would be helpful to NSF rippers by removing irrelevant information. Thus, an NSF ripper could create a stripped NSF by listening to each track while the Code/Data Logger operates on it, and then saving the stripped NSF.  It should be noted that this capability, though tested and working on private builds, is detrimental to the process of fixing broken NSF files. For this reason, data logging is allowed for NSF files, but stripping NSF files of unused data is disabled.

Created with the Personal Edition of HelpNDoc: Free help authoring tool