ctrump/ast/types.c

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.
*/

#include "ctrump/ast/types.h"
#include <stdlib.h>

#define DEFINE_BUILTIN_TYPE(str_name,c,sym)             \
    struct ctrump_texpr ctrump_builtin_##str_name = {   \
        .code = CTRUMP_TYPE_BUILTIN,                    \
        .u.builtin.code = c,                            \
        .u.builtin.name = sym,                          \
        .pointer_type = NULL,                           \
        .incomplete_array_type = NULL,                  \
        .array_types = NULL,                            \
        .func_types = NULL,                             \
        .qualified_types = NULL,                        \
    };

#include "ctrump/ast/builtin-types.def"
#undef DEFINE_BUILTIN_TYPE

#include <stdio.h>

static struct ctrump_texpr *
alloc_texpr(struct ctrump_type_env *env)
{
    struct ctrump_mempool *p = &env->type_allocator;
    struct ctrump_texpr *t = ctrump_mempool_alloc(p, sizeof(struct ctrump_texpr));

    t->id = env->id;
    t->pointer_type = NULL;
    t->incomplete_array_type = NULL;
    t->array_types = NULL;
    t->func_types = NULL;
    t->qualified_types = NULL;

    env->id++;

    return t;
}

struct ctrump_texpr *
ctrump_alloc_texpr(struct ctrump_type_env *env, enum ctrump_texpr_code code)
{
    struct ctrump_texpr *t = alloc_texpr(env);
    t->code = code;
    return t;
}


struct ctrump_texpr *
ctrump_get_typedef_name(struct ctrump_type_env *env,
                        struct ctrump_texpr *orig_type,
                        const struct ctrump_symbol *name)
{
    struct ctrump_texpr *ret = alloc_texpr(env);

    ret->code = CTRUMP_TYPE_TYPEDEF_NAME;
    ret->u.typedef_name.defined_to = orig_type;
    ret->u.typedef_name.def_name = name;

    return ret;
}


struct ctrump_texpr *
ctrump_get_qualified_attr_type(struct ctrump_type_env *env,
                               struct ctrump_texpr *orig_t,
                               int qual_flags,
                               const struct ctrump_gccext_attribute *attr)
{
    int attr_aligned;
    int attr_flags = 0;
    struct ctrump_qualified_type_chain *qc, **chain;
    struct ctrump_texpr *t;

    if (orig_t->code == CTRUMP_TYPE_QUALIFIED) {
        /* merge qualifier & get original typespec*/
        if (attr->aligned != CTRUMP_ALIGN_UNSPECIFIED) {
            attr_aligned = attr->aligned;
        } else {
            attr_aligned = orig_t->u.qualified.attr.aligned;
        }
        qual_flags = qual_flags | orig_t->u.qualified.qual_flags;
        orig_t = orig_t->u.qualified.unqualified_type;
    } else {
        attr_aligned = attr->aligned;
    }

    if (attr_aligned == CTRUMP_ALIGN_UNSPECIFIED &&
        attr_flags == 0 &&
        qual_flags == 0) {
        /* not qualified */
        return orig_t;
    }

    /* find qualified type */
    qc = orig_t->qualified_types;
    chain = &orig_t->qualified_types;

    while (qc) {
        if (qc->qual_flags == qual_flags &&
            qc->attr.aligned == attr_aligned &&
            qc->attr.flags == attr_flags)
            break;

        chain = &qc->chain;
        qc = qc->chain;
    }

    if (qc == NULL) {
        /* not found. chain new qualifed type */
        t = alloc_texpr(env);
        t->code = CTRUMP_TYPE_QUALIFIED;
        t->u.qualified.qual_flags = qual_flags;
        t->u.qualified.attr.aligned = attr_aligned;
        t->u.qualified.attr.flags = attr_flags;

        t->u.qualified.unqualified_type = orig_t;
        qc = ctrump_mempool_alloc(&env->type_allocator,
                                  sizeof(*t));
        qc->type = t;
        qc->attr.aligned = attr_aligned;
        qc->attr.flags = attr_flags;
        qc->qual_flags = qual_flags;
        qc->chain = NULL;

        *chain = qc;
    } else {
        t = qc->type;
    }

    return t;
}

struct ctrump_texpr *
ctrump_get_qualified_type(struct ctrump_type_env *env,
                          struct ctrump_texpr *orig_t,
                          int qual_flags)
{
    struct ctrump_gccext_attribute attr;

    if (orig_t->code == CTRUMP_TYPE_QUALIFIED) {
        attr = orig_t->u.qualified.attr;
    } else {
        attr.flags = 0;
        attr.aligned = CTRUMP_ALIGN_UNSPECIFIED;
    }
    return ctrump_get_qualified_attr_type(env, orig_t, qual_flags, &attr);
}

struct ctrump_texpr *
ctrump_get_unqualified_type(struct ctrump_texpr *texpr)
{
    if (texpr->code == CTRUMP_TYPE_QUALIFIED) {
        return texpr->u.qualified.unqualified_type;
    } else {
        return texpr;
    }
}


struct ctrump_texpr *
ctrump_get_pointer_type(struct ctrump_type_env *env,
                        struct ctrump_texpr *texpr)
{
    struct ctrump_texpr *t;
    if (texpr->pointer_type)
        return texpr->pointer_type;

    t = alloc_texpr(env);

    t->code = CTRUMP_TYPE_POINTER;

    t->u.pointer_to = texpr;
    texpr->pointer_type = t;

    return t;
}

struct ctrump_texpr *
ctrump_get_incomplete_array_type(struct ctrump_type_env *env,
                                 struct ctrump_texpr *texpr)
{
    struct ctrump_texpr *t;
    if (texpr->incomplete_array_type)
        return texpr->incomplete_array_type;

    t = alloc_texpr(env);

    t->code = CTRUMP_TYPE_INCOMPLETE_ARRAY;

    t->u.incomplete_array_of = texpr;

    texpr->incomplete_array_type = t;

    return t;
}

struct ctrump_texpr *
ctrump_get_varlen_array_type(struct ctrump_type_env *env,
                             struct ctrump_texpr *texpr)
{
    struct ctrump_texpr *t;
    t = alloc_texpr(env);
    t->code = CTRUMP_TYPE_VARLEN_ARRAY;
    t->u.varlen_array_of = texpr;
    return t;
}

struct ctrump_texpr *
ctrump_get_array_type(struct ctrump_type_env *env,
                      struct ctrump_texpr *texpr,
                      int size)
{
    struct ctrump_array_type_chain *t = texpr->array_types;
    struct ctrump_texpr *array_type;
    struct ctrump_array_type_chain **chain_ptr = &texpr->array_types;

    while (t) {
        if (t->size == size)
            break;
        chain_ptr = &t->chain;
        t = t->chain;
    }

    if (t) {
        return t->t;
    }

    t = ctrump_mempool_alloc(&env->type_allocator, sizeof(*t));

    array_type = alloc_texpr(env);
    array_type->code = CTRUMP_TYPE_ARRAY;

    array_type->u.array.array_of = texpr;
    array_type->u.array.size = size;

    *chain_ptr = t;
    t->t = array_type;
    t->size = size;
    t->chain = NULL;

    return array_type;
}

void
ctrump_get_functype_begin(struct ctrump_get_functype_iterator *iter,
                          struct ctrump_type_env *env,
                          struct ctrump_texpr *ret_type,
                          int num_args)
{
    struct ctrump_func_type_node *n;

    n = ret_type->func_types;

    if (n == NULL) {
        n = ctrump_mempool_alloc(&env->type_allocator, sizeof(*n));
        n->arg_type = NULL;
        n->brother = NULL;
        n->child = NULL;
        n->func_type = NULL;
        ret_type->func_types = n;
    }

    iter->cur = n;
    iter->args = NULL;
    if (num_args) {
        iter->args = malloc(sizeof(struct ctrump_texpr*) * num_args);
    }
    iter->ret = ret_type;
    iter->cur_arg = 0;
}

void
ctrump_get_functype_next(struct ctrump_type_env *env,
                         struct ctrump_get_functype_iterator *iter,
                         struct ctrump_texpr *arg)
{
    int cur_arg = iter->cur_arg;
    struct ctrump_func_type_node *n, **chain;

    chain = &iter->cur->child;
    n = *chain;

    while (n) {
        if (n->arg_type == arg) {
            break;
        }

        chain = &n->brother;
        n = *chain;
    }

    if (n == NULL) {
        n = ctrump_mempool_alloc(&env->type_allocator, sizeof(*n));
        *chain = n;
        n->arg_type = arg;
        n->brother = NULL;
        n->child = NULL;
        n->func_type = NULL;
    }

    iter->cur = n;
    iter->args[cur_arg++] = arg;
    iter->cur_arg = cur_arg;
}

struct ctrump_texpr *
ctrump_get_functype_end(struct ctrump_type_env *env,
                        struct ctrump_get_functype_iterator *iter,
                        int has_unspec_arg)
{
    int arg_num = iter->cur_arg;
    struct ctrump_func_type_node *n;
    struct ctrump_texpr *fun_type;
    int i;

    n = iter->cur;
    fun_type = n->func_type;

    if (fun_type == NULL) {
        fun_type = alloc_texpr(env);
        fun_type->code = CTRUMP_TYPE_FUNC;
        fun_type->u.func.has_unspecified_arg = has_unspec_arg;
        fun_type->u.func.arg_num = arg_num;
        fun_type->u.func.ret = iter->ret;
        fun_type->u.func.args = ctrump_mempool_alloc(&env->type_allocator,
                                                     sizeof(struct ctrump_texpr *)*arg_num);

        for (i=0; i<arg_num; i++) {
            fun_type->u.func.args[i] = iter->args[i];
        }

        n->func_type = fun_type;
    }
    if (iter->args)
        free(iter->args);

    return fun_type;
}

void
ctrump_get_functype_cancel(struct ctrump_get_functype_iterator *iter)
{
    if (iter->args)
        free(iter->args);
}

struct ctrump_texpr *
ctrump_get_incomplete_struct_type(struct ctrump_type_env *env,
                                  enum ctrump_texpr_code code,
                                  const struct ctrump_symbol *name)
{
    struct ctrump_texpr *ret = alloc_texpr(env);
    ret->code = code;
    ret->u.struct_.is_completed = 0;
    ret->u.struct_.name = name;

    return ret;
}

void
ctrump_complete_struct_type(struct ctrump_record_type *record_type,
                            int nfield,
                            struct ctrump_record_type_field *fields,
                            struct ctrump_gccext_attribute *attr)
{
    record_type->is_completed = 1;
    record_type->nfield = nfield;
    record_type->fields = fields;
    record_type->attr = *attr;
}

struct ctrump_texpr *
ctrump_get_incomplete_enum_type(struct ctrump_type_env *env,
                                const struct ctrump_symbol *name)
{
    struct ctrump_texpr *ret = alloc_texpr(env);
    ret->code = CTRUMP_TYPE_ENUM;
    ret->u.enum_.name = name;
    ret->u.enum_.is_completed = 0;
    return ret;
}

void
ctrump_complete_enum_type(struct ctrump_enum_type *enum_type,
                          int nfield,
                          struct ctrump_enum_type_field *fields)
{
    enum_type->is_completed = 1;
    enum_type->nfield = nfield;
    enum_type->fields = fields;
}


void
ctrump_type_env_init(struct ctrump_type_env *env,
                     int is_char_signed)
{
    int id = 0;
    ctrump_mempool_init(&env->type_allocator, 1024);

    if (is_char_signed) {
        env->builtin_char_type = &ctrump_builtin_schar_type;
    } else {
        env->builtin_char_type = &ctrump_builtin_uchar_type;
    }

#define DEFINE_BUILTIN_TYPE(str_name, code, sym)        \
    ctrump_builtin_##str_name.id = id++;
#include "ctrump/ast/builtin-types.def"
    #undef DEFINE_BUILTIN_TYPE

    env->id = id;
}

void
ctrump_type_env_destroy(struct ctrump_type_env *env)
{
    ctrump_mempool_destroy(&env->type_allocator);
}



int
ctrump_texpr_is_pointer(struct ctrump_texpr *texpr)
{
tailcall:
    switch (texpr->code) {
    case CTRUMP_TYPE_POINTER:
        return 1;

    case CTRUMP_TYPE_QUALIFIED:
        texpr = texpr->u.qualified.unqualified_type;
        goto tailcall;

    case CTRUMP_TYPE_TYPEDEF_NAME:
        texpr = texpr->u.typedef_name.defined_to;
        goto tailcall;

    default:
        return 0;
    }
}


struct ctrump_texpr *
ctrump_texpr_apply_unary_pointer_conversion(struct ctrump_type_env *env, struct ctrump_texpr *texpr)
{
tailcall:
    switch (texpr->code) {
    case CTRUMP_TYPE_POINTER:
        return texpr;

    case CTRUMP_TYPE_ARRAY:
        texpr = texpr->u.array.array_of;
        return ctrump_get_pointer_type(env, texpr);

    case CTRUMP_TYPE_FUNC:
        return ctrump_get_pointer_type(env, texpr);

    case CTRUMP_TYPE_QUALIFIED:
        texpr = texpr->u.qualified.unqualified_type;
        goto tailcall;

    case CTRUMP_TYPE_TYPEDEF_NAME:
        texpr = texpr->u.typedef_name.defined_to;
        goto tailcall;

    default:
        return 0;
    }
}



struct ctrump_texpr *
ctrump_retrieve_pointer_type(struct ctrump_texpr *t)
{
tailcall:
    switch (t->code) {
    case CTRUMP_TYPE_POINTER:
        return t->u.pointer_to;

    case CTRUMP_TYPE_QUALIFIED:
        t = t->u.qualified.unqualified_type;
        goto tailcall;


    case CTRUMP_TYPE_TYPEDEF_NAME:
        t = t->u.typedef_name.defined_to;
        goto tailcall;

    default:
        return NULL;
    }
}

struct ctrump_texpr *
ctrump_retrieve_address_type(struct ctrump_texpr *t)
{
tailcall:
    switch (t->code) {
    case CTRUMP_TYPE_POINTER:
        return t->u.pointer_to;

    case CTRUMP_TYPE_ARRAY:
        return t->u.array.array_of;

    case CTRUMP_TYPE_QUALIFIED:
        t = t->u.qualified.unqualified_type;
        goto tailcall;


    case CTRUMP_TYPE_TYPEDEF_NAME:
        t = t->u.typedef_name.defined_to;
        goto tailcall;

    default:
        return NULL;
    }
}



struct ctrump_gccext_attribute
ctrump_merge_attr(const struct ctrump_gccext_attribute *decl_attr,
                  const struct ctrump_gccext_attribute *var_attr)
{
    struct ctrump_gccext_attribute ret;
    ret.flags = var_attr->flags | decl_attr->flags;

    /* priority of declspec align is higher than variable attribute */
    if (decl_attr->aligned == CTRUMP_ALIGN_UNSPECIFIED) {
        ret.aligned = var_attr->aligned;
    } else {
        ret.aligned = decl_attr->aligned;
    }

    return ret;
}

const int ctrump_builtin_type_is_float_table[] = {
    [CTRUMP_BOOL] = 0,
    [CTRUMP_CHAR] = 0,
    [CTRUMP_SCHAR] = 0,
    [CTRUMP_UCHAR] = 0,
    [CTRUMP_SSHORT] = 0,
    [CTRUMP_USHORT] = 0,
    [CTRUMP_SINT] = 0,
    [CTRUMP_UINT] = 0,
    [CTRUMP_SLONG] = 0,
    [CTRUMP_ULONG] = 0,
    [CTRUMP_SLONGLONG] = 0,
    [CTRUMP_ULONGLONG] = 0,
    [CTRUMP_FLOAT] = 1,
    [CTRUMP_DOUBLE] = 1,
    [CTRUMP_LONG_DOUBLE] = 1,
    [CTRUMP_VOID] = 0,

    /* Language Extension for CBE */
    [CTRUMP_VEC_SCHAR] = 0,
    [CTRUMP_VEC_UCHAR] = 0,
    [CTRUMP_VEC_SSHORT] = 0,
    [CTRUMP_VEC_USHORT] = 0,
    [CTRUMP_VEC_SINT] = 0,
    [CTRUMP_VEC_UINT] = 0,
    [CTRUMP_VEC_SLONG] = 0,
    [CTRUMP_VEC_ULONG] = 0,
    [CTRUMP_VEC_SLONGLONG] = 0,
    [CTRUMP_VEC_ULONGLONG] = 0,
    [CTRUMP_VEC_FLOAT] = 1,
    [CTRUMP_VEC_DOUBLE] = 1,
};
const int ctrump_builtin_type_is_scalar_table[] = {
    [CTRUMP_BOOL] = 1,
    [CTRUMP_CHAR] = 1,
    [CTRUMP_SCHAR] = 1,
    [CTRUMP_UCHAR] = 1,
    [CTRUMP_SSHORT] = 1,
    [CTRUMP_USHORT] = 1,
    [CTRUMP_SINT] = 1,
    [CTRUMP_UINT] = 1,
    [CTRUMP_SLONG] = 1,
    [CTRUMP_ULONG] = 1,
    [CTRUMP_SLONGLONG] = 1,
    [CTRUMP_ULONGLONG] = 1,
    [CTRUMP_FLOAT] = 1,
    [CTRUMP_DOUBLE] = 1,
    [CTRUMP_LONG_DOUBLE] = 1,

    [CTRUMP_VOID] = 0,

    /* Language Extension for CBE */
    [CTRUMP_VEC_SCHAR] = 0,
    [CTRUMP_VEC_UCHAR] = 0,
    [CTRUMP_VEC_SSHORT] = 0,
    [CTRUMP_VEC_USHORT] = 0,
    [CTRUMP_VEC_SINT] = 0,
    [CTRUMP_VEC_UINT] = 0,
    [CTRUMP_VEC_SLONG] = 0,
    [CTRUMP_VEC_ULONG] = 0,
    [CTRUMP_VEC_SLONGLONG] = 0,
    [CTRUMP_VEC_ULONGLONG] = 0,
    [CTRUMP_VEC_FLOAT] = 0,
    [CTRUMP_VEC_DOUBLE] = 0,
};


int
ctrump_type_is_float(const struct ctrump_texpr *texpr)
{
    return ((texpr->code == CTRUMP_TYPE_BUILTIN) &&
            ctrump_builtin_type_is_float_table[texpr->u.builtin.code]);
}

int
ctrump_type_is_scalar(const struct ctrump_texpr *type)
{
tailcall:
    switch (type->code) {
    case CTRUMP_TYPE_UNION:
    case CTRUMP_TYPE_STRUCT:
    case CTRUMP_TYPE_ARRAY:
    case CTRUMP_TYPE_INCOMPLETE_ARRAY:
    case CTRUMP_TYPE_VARLEN_ARRAY:
    case CTRUMP_TYPE_FUNC:
        return 0;

    case CTRUMP_TYPE_TYPEDEF_NAME:
        type = type->u.typedef_name.defined_to;
        goto tailcall;

    case CTRUMP_TYPE_QUALIFIED:
        type = type->u.qualified.unqualified_type;
        goto tailcall;


    case CTRUMP_TYPE_POINTER:
    case CTRUMP_TYPE_ENUM:
        return 1;

    case CTRUMP_TYPE_BUILTIN:
        return ctrump_builtin_type_is_scalar_table[type->u.builtin.code];
    }

    return 0;
}

struct ctrump_texpr *
ctrump_retrieve_typedef_name(struct ctrump_texpr *type)
{
    while (type->code == CTRUMP_TYPE_TYPEDEF_NAME) {
        type = type->u.typedef_name.defined_to;
    }

    return type;
}

int
ctrump_is_scalar_type(const struct ctrump_texpr *type)
{
    enum ctrump_texpr_code tcode = type->code;

    if (tcode == CTRUMP_TYPE_ARRAY ||
        tcode == CTRUMP_TYPE_STRUCT ||
        tcode == CTRUMP_TYPE_UNION ||
        tcode == CTRUMP_TYPE_INCOMPLETE_ARRAY ||
        tcode == CTRUMP_TYPE_VARLEN_ARRAY) {
        return 0;
    }

    return 1;
}

---