Slashdot Mirror

For those of you who are interested, Undo Software [http://undo-software.com] now supports 64-bit ARM. The press release says that it is particularly useful for developers porting code to new architectures http://undo-software.com/press...

It's mostly nothing to do with ARM and much to do with "Moving to a later Linux kernel",

You're thinking of the third item in their list.

The first item in their list does have to do with ARM; its register set is different, and OS APIs for debugging have platform dependencies - in particular, the Linux kernel handled A64 differently from A32 - and those particular developers happen to be using ptrace() and had to handle A64 differently.

The second item in their list has to do with the C library doing more atomic load/store operations on A64 for some reason; they speculate that it's "to better support multiprocessor systems."

The problem here is that the article had a misleading title; it was "ARM64 vs ARM32 -- What's different for Linux programmers" when it should have been "ARM64 vs ARM32 -- What's different for people working at a company whose core technology is a record and replay engine, which works by recording all non-deterministic input to a program and uses just-in-time compilation (JIT) to keep track of the program state". What Undo Software are doing is rather specialized and system-softwareish, and they run into issues that wouldn't affect the majority of programmers; those are the issues they're talking about.

Yes, UndoDB does indeed do reverse memory watch. As does gdb since 7.0 - the big thing UndoDB buys you is speed: gdb recording slowdown is about 50,000x, whereas UndoDB is usually less than 10x and often under 2x. (I work for Undo Software)

You can run a single process backwards and forwards on Linux with UndoDB.

E.g. after a SEGV caused by dereferencing a bad pointer, set a watchpoint on the pointer value and then run backwards to see where the pointer was last modified.

[Disclaimer: i'm a founder of Undo Software]

Not all of us :) Shameless plug time: http://undo-software.com/

In The Practice of Programming, Kernighan and Pike also say: "Debugging involves backwards reasoning, like solving murder mysteries. Something impossible occurred, and the only solid information is that it really did occur. So we must think backwards from the result to discover the reasons." The ability to go backwards when debugging is already here (e.g. UndoDB http://undo-software.com/). Running backwards to hit a watchpoint to find out why your data is corrupted is a revelation.

There is however a FANTASTIC debugger that is streets ahead, in some ways, of the *other* one.

It's not OSS either.

It doesn't have a lovely graphical interface.

But, it does run backwards so that once your program crashes or does something wrong you can work out why it happened by following to the root cause.

Have you seen UndoDB? It's a debugger, able to step Linux programs /backwards/ as well as forwards. Microsoft might have lots of eye-candy with Developer Studio, but with this tool Linux developers have a tool that lets then debug in a whole new way (and let's face it: most of us spend most of our time debugging, one way or another). It uses gdb as a front-end, and adds backwards versions of commands like next, step, finish. It's also able to rewind the program to an aribtrary point in its history. Disclaimer: I am one of the tool's authors.

And you can now use UndoDB -- extends gdb to enable you to step the code backwards as well as forwards. Great if you want to know how a particular piece fits in to the bigger picture. Also means no more "oops - I stepped too far; start again", which is nice.

Please excuse the shameless piece of self-promotion that follows. One of the really cool things about Java is RetroVue - a "bidirectional debugger" that allows the programmer to step their program backwards, or rewind to any point in the program's execution history. We've just released UndoDB - a bidirectional debugger for C/C++ (and other compiled languages). Suddenly those horrible C/C++ bugs aren't so daunting :-)