Created plugins for the Dex and Dalvik support.

1 files changed, 0 insertions, 743 deletions

diff --git a/src/arch/dalvik/context.c b/src/arch/dalvik/context.c
deleted file mode 100644
index 277fad0..0000000
--- a/src/arch/dalvik/context.c
+++ /dev/null
@@ -1,743 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * context.c - contexte lié à l'exécution d'un processeur
- *
- * Copyright (C) 2011-2017 Cyrille Bagard
- *
- *  This file is part of Chrysalide.
- *
- *  Chrysalide is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  Chrysalide is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-
-#include "context.h"
-
-
-#include <malloc.h>
-#include <stdlib.h>
-#include <string.h>
-
-
-#include "operands/register.h"
-#include "../context-int.h"
-#include "../raw.h"
-#include "../../analysis/contents/restricted.h"
-#include "../../common/sort.h"
-#include "../../format/dex/dex-int.h"
-
-
-
-/* ------------------------ MANIPULATION GLOBALE DU CONTEXTE ------------------------ */
-
-
-/* Mémorisation de données brutes dans le code */
-typedef struct _raw_data_area
-{
-    mrange_t range;                         /* Couverture à laisser en 1er */
-
-    phys_t item_len;                        /* Taille de chaque élément    */
-
-} raw_data_area;
-
-/* Définition d'un contexte pour processeur Dalkvik (instance) */
-struct _GDalvikContext
-{
-    GProcContext parent;                    /* A laisser en premier        */
-
-    raw_data_area *data;                    /* Liste de zones brutes       */
-    size_t count;                           /* Taille de cette liste       */
-    GMutex mutex;                           /* Accès à la liste            */
-
-};
-
-
-/* Définition d'un contexte pour processeur Dalkvik (classe) */
-struct _GDalvikContextClass
-{
-    GProcContextClass parent;               /* A laisser en premier        */
-
-};
-
-
-/* Initialise la classe des contextes de processeur Dalkvik. */
-static void g_dalvik_context_class_init(GDalvikContextClass *);
-
-/* Initialise une instance de contexte de processeur Dalkvik. */
-static void g_dalvik_context_init(GDalvikContext *);
-
-/* Supprime toutes les références externes. */
-static void g_dalvik_context_dispose(GDalvikContext *);
-
-/* Procède à la libération totale de la mémoire. */
-static void g_dalvik_context_finalize(GDalvikContext *);
-
-
-
-/* ------------------------- CONTEXTE POUR LA DECOMPILATION ------------------------- */
-
-
-#if 0
-/* Définition d'un contexte pour décompilation Dalkvik (instance) */
-struct _GDalvikDContext
-{
-    GDecContext parent;                     /* A laisser en premier        */
-
-    GDecInstruction *this;                  /* Représentation de la classe */
-    GHashTable *args;                       /* Correspondance arg./pseudo  */
-    GHashTable *locals;                     /* Correspondance var./pseudo  */
-    size_t locals_count;                    /* Quantité de var. locales    */
-
-};
-
-
-/* Définition d'un contexte pour décompilation Dalkvik (classe) */
-struct _GDalvikDContextClass
-{
-    GDecContextClass parent;                /* A laisser en premier        */
-
-};
-
-
-/* Initialise la classe des contextes de décompilation Dalkvik. */
-static void g_dalvik_dcontext_class_init(GDalvikDContextClass *);
-
-/* Initialise une instance de contexte de décompilation Dalkvik. */
-static void g_dalvik_dcontext_init(GDalvikDContext *);
-
-/* Supprime toutes les références externes. */
-static void g_dalvik_dcontext_dispose(GDalvikDContext *);
-
-/* Procède à la libération totale de la mémoire. */
-static void g_dalvik_dcontext_finalize(GDalvikDContext *);
-
-/* Duplique un contexte de compilation. */
-static GDalvikDContext *g_dalvik_dcontext_dup(GDalvikDContext *);
-
-/* Propage un registre alloué et attendu par la suite. */
-static void g_dalvik_context_spread_allocated_shared_reg(GDalvikDContext *, GDalvikRegister *, GDecInstruction *);
-
-/* Convertit un registre machine en un pseudo-registre. */
-static GDecInstruction *g_dalvik_dcontext_convert_register(GDalvikDContext *, GDalvikRegisterOperand *, bool, vmpa_t);
-#endif
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                          MANIPULATION GLOBALE DU CONTEXTE                          */
-/* ---------------------------------------------------------------------------------- */
-
-
-/* Indique le type définit par la GLib pour le contexte de processeur Dalkvik. */
-G_DEFINE_TYPE(GDalvikContext, g_dalvik_context, G_TYPE_PROC_CONTEXT);
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : klass = classe à initialiser.                                *
-*                                                                             *
-*  Description : Initialise la classe des contextes de processeur Dalkvik.    *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_dalvik_context_class_init(GDalvikContextClass *klass)
-{
-    GObjectClass *object;                   /* Autre version de la classe  */
-
-    object = G_OBJECT_CLASS(klass);
-
-    object->dispose = (GObjectFinalizeFunc/* ! */)g_dalvik_context_dispose;
-    object->finalize = (GObjectFinalizeFunc)g_dalvik_context_finalize;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : ctx = instance à initialiser.                                *
-*                                                                             *
-*  Description : Initialise une instance de contexte de processeur Dalkvik.   *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_dalvik_context_init(GDalvikContext *ctx)
-{
-    g_mutex_init(&ctx->mutex);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : ctx = instance d'objet GLib à traiter.                       *
-*                                                                             *
-*  Description : Supprime toutes les références externes.                     *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_dalvik_context_dispose(GDalvikContext *ctx)
-{
-    g_mutex_clear(&ctx->mutex);
-
-    G_OBJECT_CLASS(g_dalvik_context_parent_class)->dispose(G_OBJECT(ctx));
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : ctx = instance d'objet GLib à traiter.                       *
-*                                                                             *
-*  Description : Procède à la libération totale de la mémoire.                *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_dalvik_context_finalize(GDalvikContext *ctx)
-{
-    if (ctx->data != NULL)
-        free(ctx->data);
-
-    G_OBJECT_CLASS(g_dalvik_context_parent_class)->finalize(G_OBJECT(ctx));
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : -                                                            *
-*                                                                             *
-*  Description : Crée un contexte pour l'exécution du processeur Dalvik.      *
-*                                                                             *
-*  Retour      : Contexte mis en place.                                       *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GDalvikContext *g_dalvik_context_new(void)
-{
-    GDalvikContext *result;                 /* Structure à retourner       */
-
-    result = g_object_new(G_TYPE_DALVIK_CONTEXT, NULL);
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : ctx    = contexte de désassemblage Dalvik à actualiser.      *
-*                start  = début de la zone à considérer.                      *
-*                length = taille de la zone couverte.                         *
-*                                                                             *
-*  Description : Mémorise une zone comme étant des données de branchements.   *
-*                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-bool g_dalvik_context_register_switch_data(GDalvikContext *ctx, const vmpa2t *start, phys_t length)
-{
-    bool result;                            /* Bilan à retourner           */
-    raw_data_area new;                      /* Nouvel élément à insérer    */
-    size_t i;                               /* Boucle de parcours          */
-
-    result = true;
-
-    g_mutex_lock(&ctx->mutex);
-
-    /* Vérification quant aux chevauchements */
-
-    init_mrange(&new.range, start, length);
-
-    for (i = 0; i < ctx->count && result; i++)
-        result = !mrange_intersects_mrange(&ctx->data[i].range, &new.range);
-
-    /* Insertion d'une nouvelle zone */
-
-    if (result)
-    {
-        new.item_len = 4;
-
-        ctx->data = qinsert(ctx->data, &ctx->count, sizeof(raw_data_area),
-                            (__compar_fn_t)cmp_mrange_with_vmpa_swapped, &new);
-
-    }
-
-    g_mutex_unlock(&ctx->mutex);
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : ctx    = contexte de désassemblage Dalvik à actualiser.      *
-*                start  = début de la zone à considérer.                      *
-*                width  = taille de chacun des éléments.                      *
-*                length = taille de la zone couverte.                         *
-*                                                                             *
-*  Description : Mémorise une zone comme étant des données d'un tableau.      *
-*                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-bool g_dalvik_context_register_array_data(GDalvikContext *ctx, const vmpa2t *start, uint16_t width, phys_t length)
-{
-    bool result;                            /* Bilan à retourner           */
-    raw_data_area new;                      /* Nouvel élément à insérer    */
-    size_t i;                               /* Boucle de parcours          */
-
-    result = true;
-
-    g_mutex_lock(&ctx->mutex);
-
-    /* Vérification quant aux chevauchements */
-
-    init_mrange(&new.range, start, length);
-
-    for (i = 0; i < ctx->count && result; i++)
-        result = !mrange_intersects_mrange(&ctx->data[i].range, &new.range);
-
-    /* Insertion d'une nouvelle zone */
-
-    if (result)
-    {
-        new.item_len = width;
-
-        ctx->data = qinsert(ctx->data, &ctx->count, sizeof(raw_data_area),
-                            (__compar_fn_t)cmp_mrange_with_vmpa_swapped, &new);
-
-    }
-
-    g_mutex_unlock(&ctx->mutex);
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : ctx     = contexte de désassemblage Dalvik à consulter.      *
-*                content = flux de données à analyser.                        *
-*                pos     = position courante dans ce flux. [OUT]              *
-*                                                                             *
-*  Description : Place une donnée en tant qu'instruction si besoin est.       *
-*                                                                             *
-*  Retour      : Instruction mise en place ou NULL en cas d'échec.            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GArchInstruction *g_dalvik_context_get_raw_data(GDalvikContext *ctx, const GBinContent *content, vmpa2t *pos)
-{
-    GArchInstruction *result;               /* Instruction à retourner     */
-    raw_data_area *found;                   /* Zone de couverture trouvée  */
-    GBinContent *restricted;                /* Zone de lecture effective   */
-
-    result = NULL;
-
-    g_mutex_lock(&ctx->mutex);
-
-    found = bsearch(pos, ctx->data, ctx->count, sizeof(raw_data_area),
-                    (__compar_fn_t)cmp_mrange_with_vmpa_swapped);
-
-    if (found)
-    {
-        restricted = g_restricted_content_new_ro(content, &found->range);
-
-        switch (found->item_len)
-        {
-            case 1:
-                result = g_raw_instruction_new_array(restricted, MDS_8_BITS_UNSIGNED, 1, pos, SRE_LITTLE);
-                break;
-
-            case 2:
-                result = g_raw_instruction_new_array(restricted, MDS_16_BITS_UNSIGNED, 1, pos, SRE_LITTLE);
-                break;
-
-            case 4:
-                result = g_raw_instruction_new_array(restricted, MDS_32_BITS_UNSIGNED, 1, pos, SRE_LITTLE);
-                break;
-
-            case 8:
-                result = g_raw_instruction_new_array(restricted, MDS_64_BITS_UNSIGNED, 1, pos, SRE_LITTLE);
-                break;
-
-            default:
-                result = g_raw_instruction_new_array(restricted, MDS_8_BITS_UNSIGNED,
-                                                     found->item_len, pos, SRE_LITTLE);
-                break;
-
-        }
-
-        g_object_unref(G_OBJECT(restricted));
-
-    }
-
-    g_mutex_unlock(&ctx->mutex);
-
-    return result;
-
-}
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                           CONTEXTE POUR LA DECOMPILATION                           */
-/* ---------------------------------------------------------------------------------- */
-
-
-#if 0
-/* Indique le type définit par la GLib pour le contexte de décompilation Dalkvik. */
-G_DEFINE_TYPE(GDalvikDContext, g_dalvik_dcontext, G_TYPE_DEC_CONTEXT);
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : class = classe à initialiser.                                *
-*                                                                             *
-*  Description : Initialise la classe des contextes de décompilation Dalkvik. *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_dalvik_dcontext_class_init(GDalvikDContextClass *class)
-{
-    GObjectClass *object;                   /* Autre version de la classe  */
-
-    object = G_OBJECT_CLASS(class);
-
-    object->dispose = (GObjectFinalizeFunc/* ! */)g_dalvik_dcontext_dispose;
-    object->finalize = (GObjectFinalizeFunc)g_dalvik_dcontext_finalize;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : ctx = instance à initialiser.                                *
-*                                                                             *
-*  Description : Initialise une instance de contexte de décompilation Dalkvik.*
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_dalvik_dcontext_init(GDalvikDContext *ctx)
-{
-    GDecContext *parent;                    /* Instance parente            */
-
-    ctx->args = g_hash_table_new(g_constant_hash, g_direct_equal);
-    ctx->locals = g_hash_table_new(g_constant_hash, g_direct_equal);
-
-    parent = G_DEC_CONTEXT(ctx);
-
-    parent->dup = (dup_dec_context_fc)g_dalvik_dcontext_dup;
-    parent->spread = (spread_reg_fc)g_dalvik_context_spread_allocated_shared_reg;
-    parent->convert_reg = (convert_register_fc)g_dalvik_dcontext_convert_register;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : ctx = instance d'objet GLib à traiter.                       *
-*                                                                             *
-*  Description : Supprime toutes les références externes.                     *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_dalvik_dcontext_dispose(GDalvikDContext *ctx)
-{
-    if (ctx->this != NULL)
-        g_object_unref(G_OBJECT(ctx->this));
-
-    G_OBJECT_CLASS(g_dalvik_dcontext_parent_class)->dispose(G_OBJECT(ctx));
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : ctx = instance d'objet GLib à traiter.                       *
-*                                                                             *
-*  Description : Procède à la libération totale de la mémoire.                *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_dalvik_dcontext_finalize(GDalvikDContext *ctx)
-{
-    G_OBJECT_CLASS(g_dalvik_dcontext_parent_class)->finalize(G_OBJECT(ctx));
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : -                                                            *
-*                                                                             *
-*  Description : Crée un contexte pour la décompilation Dalvik.               *
-*                                                                             *
-*  Retour      : Contexte mis en place.                                       *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GDalvikDContext *g_dalvik_dcontext_new(void)
-{
-    GDalvikDContext *result;                /* Structure à retourner       */
-
-    result = g_object_new(G_TYPE_DALVIK_DCONTEXT, NULL);
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : orig = contexte de compilation à copier.                     *
-*                                                                             *
-*  Description : Duplique un contexte de compilation.                         *
-*                                                                             *
-*  Retour      : Contexte de décompilation prêt à emploi.                     *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static GDalvikDContext *g_dalvik_dcontext_dup(GDalvikDContext *orig)
-{
-    GDalvikDContext *result;                /* Structure à retourner       */
-
-    result = g_object_new(G_TYPE_DALVIK_DCONTEXT, NULL);
-
-    //g_object_unref(G_OBJECT(result->args));
-    //g_object_unref(G_OBJECT(result->locals));
-
-    _g_dec_context_dup(G_DEC_CONTEXT(result), G_DEC_CONTEXT(orig));
-
-    if (orig->this != NULL) g_object_ref(G_OBJECT(orig->this));
-    //g_object_ref(G_OBJECT(orig->args));
-    //g_object_ref(G_OBJECT(orig->locals));
-
-    result->this = orig->this;
-    result->args = orig->args;
-    result->locals = orig->locals;
-    result->locals_count = orig->locals_count;
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : parent = instance à éventuellement compléter.                *
-*                child  = instance à venir consulter.                         *
-*                                                                             *
-*  Description : Propage un registre alloué et attendu par la suite.          *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_dalvik_context_spread_allocated_shared_reg(GDalvikDContext *ctx, GDalvikRegister *reg, GDecInstruction *dinstr)
-{
-    GDexFormat *format;                     /* Recherche de méthode        */
-    GBinRoutine *routine;                   /* Objet des recherches        */
-    GDexMethod *method;                     /* Méthode décompilée          */
-    uint16_t index;                         /* Identifiant du registre     */
-    DexVariableIndex info;                  /* Nature du registre          */
-
-    format = G_DEX_FORMAT(G_DEC_CONTEXT(ctx)->format);
-    routine = G_DEC_CONTEXT(ctx)->routine;
-
-    method = g_dex_format_find_method_by_address(format, g_binary_routine_get_address(routine));
-
-    index = g_dalvik_register_get_index(reg);
-    info = g_dex_method_get_variable(method, index);
-
-    g_object_ref(G_OBJECT(dinstr));
-    g_hash_table_insert(ctx->locals, GUINT_TO_POINTER(DVI_INDEX(info)), dinstr);
-    ctx->locals_count++;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : ctx     = instance à consulter, voire mettre à jour.         *
-*                operand = opérande représentant un registre quelconque.      *
-*                assign  = précise le sort prochain du registre.              *
-*                addr    = adresse de l'instruction décompilée.               *
-*                                                                             *
-*  Description : Convertit un registre machine en un pseudo-registre.         *
-*                                                                             *
-*  Retour      : Pseudo-registre, existant ou non, prêt à emploi.             *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static GDecInstruction *g_dalvik_dcontext_convert_register(GDalvikDContext *ctx, GDalvikRegisterOperand *operand, bool assign, vmpa_t addr)
-{
-    GDecInstruction *result;                /* Instance à retourner        */
-    GDexFormat *format;                     /* Recherche de méthode        */
-    GBinRoutine *routine;                   /* Objet des recherches        */
-    GDexMethod *method;                     /* Méthode décompilée          */
-    const GDalvikRegister *reg;             /* Registre Dalvik représenté  */
-    uint16_t index;                         /* Identifiant du registre     */
-    DexVariableIndex info;                  /* Nature du registre          */
-    GBinVariable *this;                     /* Définition de "this"        */
-    gpointer *found;                        /* Pseudo-registre trouvé      */
-
-    format = G_DEX_FORMAT(G_DEC_CONTEXT(ctx)->format);
-    routine = G_DEC_CONTEXT(ctx)->routine;
-
-    method = g_dex_format_find_method_by_address(format, g_binary_routine_get_address(routine));
-
-    reg = g_dalvik_register_operand_get(operand);
-
-    index = g_dalvik_register_get_index(reg);
-    info = g_dex_method_get_variable(method, index);
-
-    /* Objet "this" */
-    if (info & DVI_THIS)
-    {
-        if (ctx->this == NULL)
-        {
-            this = g_binary_variable_new(/* FIXME */g_basic_type_new(BTP_OTHER) /* FIXME */);
-            g_binary_variable_set_name(this, "this");
-
-            ctx->this = g_pseudo_register_new(PRU_THIS);
-            g_pseudo_register_set_variable(G_PSEUDO_REGISTER(ctx->this), this);
-
-        }
-
-        g_object_ref(G_OBJECT(ctx->this));
-        result = ctx->this;
-
-    }
-
-    /* Argument d'appel */
-    else if (info & DVI_ARGUMENT)
-    {
-        found = g_hash_table_lookup(ctx->args, GUINT_TO_POINTER(DVI_INDEX(info)));
-
-        if (found != NULL)
-        {
-            g_object_ref(G_OBJECT(found));
-            result = G_DEC_INSTRUCTION(found);
-        }
-        else
-        {
-            result = g_pseudo_register_new(PRU_ARG);
-            g_pseudo_register_set_basename(G_PSEUDO_REGISTER(result), "arg");
-            g_pseudo_register_set_index(G_PSEUDO_REGISTER(result), DVI_INDEX(info));
-
-            g_hash_table_insert(ctx->args, GUINT_TO_POINTER(DVI_INDEX(info)), result);
-
-        }
-
-    }
-
-    /* Variable locale */
-    else
-    {
-        found = g_hash_table_lookup(ctx->locals, GUINT_TO_POINTER(DVI_INDEX(info)));
-
-        if (!assign && found != NULL)
-        {
-            g_object_ref(G_OBJECT(found));
-            result = G_DEC_INSTRUCTION(found);
-        }
-        else
-        {
-            /*
-            if (!assign)
-            {
-                printf("bug");
-                exit(0);
-            }
-            */
-
-            result = g_dec_context_get_awaited_alloc(G_DEC_CONTEXT(ctx), G_ARCH_REGISTER(reg), addr);
-
-            if (result == NULL)
-            {
-                result = g_pseudo_register_new(PRU_LOCAL);
-                g_pseudo_register_set_basename(G_PSEUDO_REGISTER(result), "var");
-                g_pseudo_register_set_index(G_PSEUDO_REGISTER(result), ctx->locals_count);
-
-                g_dec_context_notify_reg_alloc(G_DEC_CONTEXT(ctx), G_ARCH_REGISTER(reg),
-                                               result, addr);
-
-            }
-            else
-                g_object_ref(G_OBJECT(result));
-
-            g_object_ref(G_OBJECT(result));
-            g_hash_table_insert(ctx->locals, GUINT_TO_POINTER(DVI_INDEX(info)), result);
-            ctx->locals_count++;
-
-        }
-
-    }
-
-    return result;
-
-}
-#endif