named_lin_ineq.cc

c到DHL的转换工具

/* file "named_lin_ineq.cc" */

/*  Copyright (c) 1994 Stanford University

    All rights reserved.

    This software is provided under the terms described in
    the "suif_copyright.h" include file. */

#include <suif_copyright.h>

#define _MODULE_ "libsuifmath.a"
#pragma implementation "named_lin_ineq.h"

#include <stdio.h>
#include <suif1.h>
#include <builder.h>
#include "suifmath.h"


int named_lin_ineq::unum_cnt = 0;



/* ##################################################
   #####   name_table_entry                     #####
   ################################################## */

name_table_entry::~name_table_entry()
{

}

/***************************************************************************
 *                                                                         *
 ***************************************************************************/

void name_table_entry::init(const immed & im)
{
    if(im.is_symbol()) {
        assert(im.symbol()->is_var());
        is_var = TRUE;
        vsname.v = (var_sym *)im.symbol();
        knd = nte_symconst;
    } else if(im.is_string()) {
        is_var = FALSE;
        vsname.s = im.string();
        knd = nte_symconst;
    } else {
        is_var = FALSE;
        vsname.s = NULL;
        knd = nte_aux;
    }
}


void name_table_entry::init(name_table_entry_kind k,
                            const immed & im)
{
    init(im);
    // assert(knd != nte_aux);
    knd = k;

}

void name_table_entry::set_name(const immed & im)
{
    name_table_entry_kind kk = kind();
    init(im);
    if(kind() != nte_aux) {
        knd = kk;
        if((kind() == nte_aux)||
           (kind() == nte_none))
            knd = nte_symconst;
    }
}

/***************************************************************************
 *                                                                         *
 ***************************************************************************/
void name_table_entry::init(const name_table_entry & nte)
{
    knd = nte.knd;
    is_var = nte.is_var;
    if(is_var)
        vsname.v = nte.vsname.v;
    else
        vsname.s = nte.vsname.s;
}


/***************************************************************************
 *  Following functions will change the type of a table entry              *
 ***************************************************************************/
void name_table_entry::mark_sym()
{
    assert(vsname.s);
    assert(knd != nte_aux);
    knd = nte_symconst;
}

void name_table_entry::mark_cond()
{
    assert(vsname.s);
    assert(knd != nte_aux);
    knd = nte_cond;
}

void name_table_entry::mark_loop()
{
    assert(vsname.s);
    assert(knd != nte_aux);
    knd = nte_loop;
}

void name_table_entry::mark_dim()
{
    assert(vsname.s);
    assert(knd != nte_aux);
    knd = nte_dim;
}

void name_table_entry::mark_summary()
{
    assert(vsname.s);
    assert(knd != nte_aux);
    knd = nte_summary;
}

void name_table_entry::mark_aux()
{
    knd = nte_aux;
    is_var = FALSE;
    vsname.s = NULL;
}


 /***************************************************************************
 *                                                                         *
 ***************************************************************************/
boolean name_table_entry::operator==(const name_table_entry & nte) const
{
    if((nte.knd != knd)||
       (knd == nte_aux))
        return FALSE;
    if(is_var && nte.is_var)
        return (var() == nte.var()) || var()->overlaps(nte.var());
    else
        return (nte.name() == name());
}


immed name_table_entry::name() const
{
    if(is_var) {
        assert(vsname.v);
        return immed(vsname.v);
    } else if(vsname.s)
        return immed(vsname.s);
    else
        return immed(0);
}

char * name_table_entry::string() const
{
    if(is_var) {
        assert(vsname.v);
        return vsname.v->name();
    } else
        return vsname.s;
}


static boolean is_ancestor(base_symtab * ans, base_symtab * chld)
{
    if(chld == ans) return TRUE;
    if(chld->parent() == NULL) return FALSE;
    return is_ancestor(ans, chld->parent());
}


static base_symtab * inner_symtab(base_symtab * st1, base_symtab * st2)
{
    if(is_ancestor(st1, st2)) return st2;
    if(is_ancestor(st2, st1)) return st1;
    // assert_msg(0, ("Symbols are in different scopes, no single scope that covers all the symbols used"));
    return NULL;
}


base_symtab * name_table_entry::get_symtab(base_symtab * in) const
{
    if((kind() == nte_aux)||(!is_var))
        return in;

    base_symtab * st = var()->parent();
    assert(st);

    if(in == NULL)
        return st;
    else
        return inner_symtab(st, in);
}




/* ##################################################
   #####   name_table                           #####
   ################################################## */

#define SETTABLE(N)  if(n() > N) { \
                                   if(v##N) \
                                       L[N-1].set_name(*(v##N));\
                                   else \
                                       L[N-1].mark_aux(); \
                                   }

name_table::name_table(const immed * v1,  const immed * v2,  const immed * v3,
                       const immed * v4,  const immed * v5,  const immed * v6,
                       const immed * v7,  const immed * v8,  const immed * v9,
                       const immed * v10, const immed * v11, const immed * v12,
                       const immed * v13, const immed * v14, const immed * v15,
                       const immed * v16)
{
    L = NULL;
    sz = 1;
    rsz = 1;
    int s = 1;
    if(v1) s=2;
    if(v2) s=3;
    if(v3) s=4;
    if(v4) s=5;
    if(v5) s=6;
    if(v6) s=7;
    if(v7) s=8;
    if(v8) s=9;
    if(v9) s=10;
    if(v10) s=11;
    if(v11) s=12;
    if(v12) s=13;
    if(v13) s=14;
    if(v14) s=15;
    if(v15) s=16;
    if(v16) s=17;

    init(s);

    SETTABLE(1);
    SETTABLE(2);
    SETTABLE(3);
    SETTABLE(4);
    SETTABLE(5);
    SETTABLE(6);
    SETTABLE(7);
    SETTABLE(8);
    SETTABLE(9);
    SETTABLE(10);
    SETTABLE(11);
    SETTABLE(12);
    SETTABLE(13);
    SETTABLE(14);
    SETTABLE(15);
    SETTABLE(16);
}
#undef SETTABLE

/***************************************************************************
 *                                                                         *
 ***************************************************************************/
name_table::~name_table()
{
    if(L) delete[] L;
}


name_table &name_table::operator=(const name_table &nt)
{
    init(nt);
    return *this;
}

/***************************************************************************
 *                                                                         *
 ***************************************************************************/
void name_table::resize(int newsz)
{
    assert(newsz >= 0);
    if (newsz >= rsz) {
	int osz = MIN(sz,newsz);
	name_table_entry *L1 = L;
	rsz = newsz;
        L = (rsz-1>0)?(new name_table_entry[rsz-1]):NULL;

	for(int i=1; i<osz; i++)
	    L[i-1] = L1[i-1];
        if(L1) delete[] L1;
    }
    sz = newsz;
}

void name_table::init(const name_table &nt)
{
    if(&nt == this) return;

    if(nt.n() >= rsz) {
        if(L) delete[] L;
	rsz = nt.n();
        L = (rsz-1>0)?(new name_table_entry[rsz-1]):NULL;
    };
    sz = nt.n();

    for(int i=1; i<n(); i++)
        L[i-1].init(nt.e(i));
}

/***************************************************************************
 *                                                                         *
 ***************************************************************************/
void name_table::init(int s)
{
    if(s > rsz) {
        if(L) delete[] L;
	rsz = s;
        L = (rsz-1>0)?(new name_table_entry[rsz-1]):NULL;
    };
    sz = s;
    
    for(int i=1; i<n(); i++)
        L[i-1].init();
}


/***************************************************************************
 *                                                                         *
 ***************************************************************************/
int name_table::find(const name_table_entry & nte) const
{
    for(int i=1; i<n(); i++)
        if(L[i-1] == nte) return i;
    return -1;
}


/***************************************************************************
 *                                                                         *
 ***************************************************************************/
int name_table::find(const immed & v) const
{
    for(int i=1; i<n(); i++)
        if(L[i-1].name() == v) return i;
    return -1;
}

constraint name_table::lio_code_type() const
{
    constraint c(n());
    c[0] = NM_CONSTANT;
    for(int i=1; i<n(); i++)
        switch(e(i).kind()) {
        case nte_symconst:
            c[i] = NM_CONSTANT;
            break;
        case nte_cond:
        case nte_loop:
        case nte_dim:
        case nte_summary:
            c[i] = NM_LOCATIONS;
	    break;
        case nte_aux:
        case nte_none:
            assert(0);
        }
    return c;
}

void name_table::remove(int i, int j)
{
    assert((0<i)&&(i<=j)&&(j<n()));

    int src=j+1;
    int dst=i;

    while (src<n()) {
	L[dst-1] = L[src-1];
	dst++; src++;
    };
    sz = n()-(j-i+1);
}

void name_table::remove(const integer_row & mask)
{
    int src, dst;
    assert(mask.n() == n());

    for (dst=1, src=1; (src <  n()); src++) {
	if (!mask.c(src)) {
	    L[dst-1] = L[src-1];
	    dst++;
	};
    }

    sz = dst;
}

void name_table::insert(const name_table_entry & nte, int i)
{
    assert((i>=1)&&(i<=n()));
    if (sz >= rsz) {
	int lln = MAX(n()-1+1,(n()-1)*2);
	name_table_entry * LL = (lln>0)?(new name_table_entry[lln]):NULL;

	int k;
	for(k=1; k<i; k++)
	    LL[k-1] = L[k-1];
	LL[i-1].init(nte);
	for(k=i; k<n(); k++)
	    LL[k] = L[k-1];
	
	if(L) delete[] L;
	L = LL;
	sz++;
	rsz = lln+1;
    } else {
	for (int k=sz; k>i; k--)
	    L[k-1] = L[k-2];
	L[i-1].init(nte);
	sz++;
    }
}

void name_table::insert(const immed & v, int i)
{
    insert(name_table_entry(v), i);
}



/***************************************************************************
 * use B and change A                                                      *
 ***************************************************************************/
void name_table::change_name_types(name_table & na, name_table & nb)
{
    for(int i=1; i<nb.n(); i++) {
        immed bv(nb.e(i).name());
        if(bv.is_symbol() || bv.is_string()) {     // not an aux
            int j = na.find(bv);
            if(j > 0) {
                name_table_entry_kind ka = na.e(j).kind();
                name_table_entry_kind kb = nb.e(i).kind();
                name_table_entry_kind kk = nte_none;
                if(ka == kb)
                    kk = kb;
                else if(ka == nte_none)
                    kk = kb;
                else if(kb == nte_none) /* can't happen */
                    kk = ka;
                else if(ka == nte_symconst)
                    kk = kb;
                else if(kb == nte_symconst)
                    kk = ka;
                else if((ka == nte_cond)&&(kb == nte_loop))
                    kk = nte_cond;
                else if((kb == nte_cond)&&(ka == nte_loop))
                    kk = nte_cond;
                else if((ka == nte_summary)||(kb == nte_summary))
                    kk = nte_summary;
                else
                    assert(0);
                na[j].knd = kk;
                nb[i].knd = kk;
            }
        }
    }
}