How to check when a division by zero happends (x86)

This piece of code was gold for me (thanks to Harry !)  :

    uint32_t mxcsr;
    uint32_t mask = 0;
    //mask |= 1 << 12; // precision mask
    mask |= 1 << 11;   // under flow mask 
    mask |= 1 << 10;   // over flow mask
    mask |= 1 << 9;    // division by zero mask
    mask |= 1 << 7;    // invalid operator mask
    mask = ~mask;
    asm volatile ("stmxcsr %0" : "=m"(mxcsr));
    mxcsr &= mask;
    asm volatile ("ldmxcsr %0" : : "m"(mxcsr));

When you add it, then any division by zero (or other type of error you had to the mask) will trigger an floating point exception. This can save you a day (or two)…

Building a compiler with Crosstool-ng

What is crosstool-ng : http://www.crosstool-ng.org/

Step 1 – Preparation

Download and compile it :

$  git clone git://crosstool-ng.org/crosstool-ng
$  cd crosstool-ng
$  ./configure --enable-local 
$  make

Step 2 – Configuration

Configure your target (ex: arm architecture) :

$ ./ct-ng arm-unknown-linux-gnueabi

If you are not sure about the target you need, you can check the existing ones :

$ ./ct-ng list-samples
....
[L..] armeb-unknown-linux-gnueabi
....
[L..] x86_64-unknown-linux-gnu
[L..] x86_64-unknown-linux-uclibc
[L.X] x86_64-w64-mingw32
[L..] xtensa-unknown-linux-uclibc
 L (Local) : sample was found in current directory
 G (Global) : sample was installed with crosstool-NG
 X (EXPERIMENTAL): sample may use EXPERIMENTAL features
 B (BROKEN) : sample is currently broken

Step 3 – Generation

Generate the compiler :

$ ./ct-ng build

Usage

Once the compilation is done,

$ export PATH=crosstool-ng/.build/arm-unknown-linux-gnueabi/buildtools/bin/:$PATH
$ export CCPREFIX := arm-unknown-linux-gnueabi-
$ export AS := $(CCPREFIX)as
$ export LD := $(CCPREFIX)ld
$ export CC := $(CCPREFIX)gcc
$ export AR := $(CCPREFIX)ar

You can also repeat the build operation on different target to generate all you need:

$ ./ct-ng arm-unknown-linux-gnueabi 
$ ./ct-ng build
$ export PATH=crosstool-ng/.build/arm-unknown-linux-gnueabi/buildtools/bin/:$PATH

Possible errors

[ERROR] g++-4.6.real: internal compiler error: Killed (program cc1plus)

This happended to me on a board with not enough memory. You can temporarily add more swap :

dd if=/dev/zero of=swap.img bs=1024k count=1000
mkswap swap.img
swapon swap.img

Sources

Building embedded ARM systems with Crosstool-NG

Ces petits projets que l’on commence sans jamais les finir …

Après tout je ne suis pas le seul dans cette situation, on commence beaucoup de chose, mais on ne finit rien …
Je pense que désormais avant de les commencer j’en toucherai un mot par là histoire de ne pas les oublier trop vite 🙂

Je me lance donc, voici War3Listen 🙂

Je suis joueur de Warcraft 3 et un petit problème me titille depuis quelques temps, les utilisateurs des logiciels tels que W3banlist.
Pour les néophytes il s’agit d’une application qui permet, d’une part d’identifier l’adresse IP et le pays des joueurs, d’autre part de « bannir » ceux d’on le comportement n’est pas jugé fair-play (je ne polémiquerais pas sur les abus possibles avec ces options).

Au stade de mon travail, je ne sais pas si je respecte la lois. Mais n’ayant fait aucune modification dans le comportement du jeu lui même (pas de triche) je ne pense pas.

Planning du projet

1 : identifier une méthode pour récupérer les adresses IP utilisateurs
2 : Trouver la méthode la plus rapide pour obtenir à partir d’une IP la nationalité et le drapeau du joueur.
3 : communiquer en plein jeu l’information (nationalité et temps de réponse).

Avancement

A ce stade, j’ai déjà trouvé et traduit les paquets qui détenaient l’information utile. En ce qui concerne la récupération en temps réel, je pense faire une note sur la méthode utilisée, c’est assez intéressant.

J’ai aussi trouvé de quoi communiquer avec le joueur, XOSD marche à la perfection.

Ce qu’il reste à faire

Et bien il reste le plus rébarbatif, tout assembler. De même je n’ai pas encore cherché comment passer d’une adresse IP à un pays.

[Langage C] Quelques notions …

Certains vous le diront, même sans jamais avoir programmé en C, tant d’exemples l’utilisent que l’on en connaît forcement les bases. C’était aussi mon cas, mais après avoir commencé à vraiment l’utiliser, je pense que certaines notions restent indispensable.

Par exemple je viens de decouvrir que lorsqu’un programme est compilé avec l’option -g , il est possible d’executer une applicationavec ddd ( un debugger graphique) et objdump.

De même pour générer une bibliothèque on utilisera l’option -c (on obtient un fichier .o) et il est ensuite possible de rassembler des .o au sein d’un .a avec la commande ar -cvr qqchose.a qqchose.o.

Ce sera tout votre honneur 🙂