ctrump/analyzer/var.h

Go to the documentation of this file.

/* -*- coding:utf-8 -*- 
 Copyright (c) 2009, Fixstars Corporation
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without modification, 
 are permitted provided that the following conditions are met:
 
   * Redistributions of source code must retain the above copyright notice,
     this list of conditions and the following disclaimer.
 
   * Redistributions in binary form must reproduce the above copyright notice,
     this list of conditions and the following disclaimer in the documentation
     and/or other materials provided with the distribution.
 
   * Neither the name of Fixstars Corporation nor the names of its contributors
     may be used to endorse or promote products derived from this software
     without specific prior written permission.
 
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#ifndef CTRUMP_ANALYZER_VAR_H
#define CTRUMP_ANALYZER_VAR_H

#include "ctrump/ast/expr-code.h"
#include "ctrump/common/dll.h"

#ifdef __cplusplus
extern "C" {
#endif

enum ctrump_subscript_nd_code {
    CTRUMP_SUBSCRIPT_TERMINAL,  
    CTRUMP_SUBSCRIPT_LOAD_RECORD, 
    CTRUMP_SUBSCRIPT_COEF_ARRAY,  
    CTRUMP_SUBSCRIPT_RECORD_MEMBER, 
    CTRUMP_SUBSCRIPT_RECORD_MEMBER_TERMINAL 
};

struct ctrump_subscript_coef_array {
    int coef;                   /* -1 if terminal (require memory access) */
    struct ctrump_expr *expr;   /* optional : NULL if pointer is referenced by '*' (*a => a[NULL]) */
};

struct ctrump_subscript_terminal {
    struct ctrump_expr *expr;   /* optional : NULL if pointer is referenced by '*' (*a => a[NULL]) */
    struct ctrump_texpr *load_type;
};

struct ctrump_subscript_coef_load_record {
    /* a[i].x => [load_subscript : i][record member terminal : x] */
    struct ctrump_texpr *load_type;
    struct ctrump_expr *expr;   /* optional : NULL if pointer is referenced by '*' (*a => a[NULL]) */
};

struct ctrump_subscript_record_member {
    struct ctrump_texpr *record_type;
    const struct ctrump_symbol *member_name;
};

struct ctrump_subscript_record_member_terminal {
    struct ctrump_texpr *record_type;
    struct ctrump_texpr *load_type;
    const struct ctrump_symbol *member_name;
};


struct ctrump_subscript_nd {
    enum ctrump_subscript_nd_code code;

    union {
        struct ctrump_subscript_coef_array array_coef; /* case CTRUMP_SUBSCRIPT_COEF_INTEGER */
        struct ctrump_subscript_terminal terminal;     /* case CTRUMP_SUBSCRIPT_TERMINAL */
        struct ctrump_subscript_coef_load_record load_record; /* case CTRUMP_SUBSCRIPT_COEF_LOAD_RECORD */
        struct ctrump_subscript_record_member record_member; /* case CTRUMP_SUBSCRIPT_RECORD_MEMBER */
        struct ctrump_subscript_record_member_terminal record_member_terminal; /* case CTRUMP_SUBSCRIPT_RECORD_MEMBER_TERMINAL */
    } u;
};

struct ctrump_subscript {
    int num_nd_subscript;
    struct ctrump_subscript_nd *nd_subscripts; /* vec [num_nd_subscript] */
};


struct ctrump_memory_access {
#define CTRUMP_MEMORY_ACCESS_PTRREF (1<<0)
#define CTRUMP_MEMORY_ACCESS_PARTIAL (1<<1)
    int flags;

    struct ctrump_expr *array;  
    int num_subscript;          
    struct ctrump_subscript *subscripts; /* vec [num_subscript] */

    /* for report error */
    struct ctrump_stmt *at_stmt; 
    struct ctrump_expr *at_expr; 
};

struct ctrump_memory_load {
    struct ctrump_memory_access mem_access;
};

struct ctrump_memory_store {
    enum ctrump_expr_code store_op; 
    struct ctrump_memory_access mem_access; 
    struct ctrump_expr *val;                
};

struct ctrump_var_ref {
    struct ctrump_stmt *at;     
    struct ctrump_expr *ref_expr; 
};

struct ctrump_var_store {
    enum ctrump_expr_code store_op; 
    struct ctrump_var *var;         
    int flags;
    struct ctrump_pdg_node *new_val; 
    struct ctrump_expr *var_ref;     
    struct ctrump_stmt *at;     
    struct ctrump_expr *val;    /* optional : NULL if set by initializer */
};

enum ctrump_load_store_t {
    CTRUMP_MEMORY_LOAD,
    CTRUMP_MEMORY_STORE,
};

struct ctrump_ordered_memory_load_store_node {
    enum ctrump_load_store_t code; 
    int op_index;                  
};


struct ctrump_load_store_set {
    int num_mem_load;           
    int num_mem_store;          
    int num_memop;              
    int num_ref;                
    int num_store;              
    /* var access */
    struct ctrump_var_ref *refs; 
    struct ctrump_var_store *stores; 
    /* primitive memory access */
    struct ctrump_memory_load *mem_loads; 
    struct ctrump_memory_store *mem_stores; 
    struct ctrump_ordered_memory_load_store_node *ordered_load_store; /* vec [num_memop] */
};


enum ctrump_pdg_node_code {
    CTRUMP_PDG_VALUE_EXPR,      
    CTRUMP_PDG_VALUE_REDUCTION, 
    CTRUMP_PDG_VALUE_INCREMENTAL,   
    CTRUMP_PDG_VALUE_PHI,         
    CTRUMP_PDG_VALUE_INITIALIZER, 
    CTRUMP_PDG_VALUE_UNINITIALIZED, 
    CTRUMP_PDG_VALUE_GLOBAL,        
    CTRUMP_PDG_VALUE_ARG            
};

struct ctrump_phi_node {
    int id;
    int num_merge;            
    int var_index;            
    struct ctrump_bb *merge_at;     
    struct ctrump_pdg_node **nodes; 
};

enum ctrump_reductive_expr_code {
    CTRUMP_REDUCTIVE_IDENTIFY,  
    CTRUMP_REDUCTIVE_ADD,       
    CTRUMP_REDUCTIVE_SUB,       
    CTRUMP_REDUCTIVE_MUL,       
    CTRUMP_REDUCTIVE_BOR,       
    CTRUMP_REDUCTIVE_BAND,      
    CTRUMP_REDUCTIVE_BXOR,      
    CTRUMP_REDUCTIVE_LOR,       
    CTRUMP_REDUCTIVE_LAND,      
    CTRUMP_REDUCTIVE_FADD,       
    CTRUMP_REDUCTIVE_FSUB,       
    CTRUMP_REDUCTIVE_FMUL        
};


struct ctrump_pdg_reductive_expr {
    enum ctrump_reductive_expr_code op; 
    struct ctrump_pdg_node *prev_val;   
    struct ctrump_expr *value;          
};


enum ctrump_incremental_expr_code {
    CTRUMP_PDG_INC,             
    CTRUMP_PDG_DEC,             
    CTRUMP_PDG_FINC,            
    CTRUMP_PDG_FDEC,            
};

struct ctrump_pdg_incremental_expr {
    enum ctrump_incremental_expr_code op; 
    struct ctrump_pdg_node *prev_val;     
};

struct ctrump_pdg_store_expr {
    enum ctrump_expr_code store_op; 
    struct ctrump_expr *val;        
};

struct ctrump_pdg_node {
    int id;
    enum ctrump_pdg_node_code code; 
    struct ctrump_stmt *at;  /* optional : NULL if phi_node */

    union {
        struct ctrump_pdg_reductive_expr reduction; /* case CTRUMP_PDG_VALUE_REDUCTION */
        struct ctrump_pdg_incremental_expr incr;    /* case CTRUMP_PDG_VALUE_INCREMENTAL */
        struct ctrump_pdg_store_expr expr; /* case CTRUMP_PDG_VALUE_EXPR */
        struct ctrump_phi_node *phi; /* case CTRUMP_PDG_VALUE(_LOOP)?_PHI */
        struct ctrump_initializer_list *initializer; /* case CTRUMP_PDG_VALUE_INITIALIZER */
    }u;
};

#ifdef __cplusplus
}
#endif

#endif

---