python/ctrump/builtin-optimizers/OffloadSpe.py

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.
#


"""Offlaod loop to SPE"""

from ctrump.optimizer import *
from ctrump.Builder import *
import ctrump
import ctrump.spe

EI = ctrump.ExitInfo

ALIGN_CHECK_NONE = 0
ALIGN_CHECK_16 = 1
ALIGN_CHECK_128 = 2

SPE_LIBSPE2 = 0
SPE_LIBSPE1 = 1

MFC_MAX=16384

import ctrump.libspe2

spe_runtime_table = [
    ctrump.libspe2
]

SELF_TRANSLATOR_NAME = 'SPE Offloading'

global_options_table = [
    ('address_mode', 'アドレスモード',
     '''64bitアドレスか32bitアドレスかを指定します''', [('32',32), ('64',64)]),

    ('max_spe_num', 'SPEの最大数',
     '''SPEの最大数を指定します。
パラメータを入れる配列のサイズを指定するのに使います
''',
     6)

#     ('get_spe_expr', 'SPEオブジェクトを取得する式',
# '''SPEオブジェクトを取得する式を設定します
# 文字列中に含まれる %s が実行時のSPEを示す変数に置きかえられます
# spes[%s] のように指定すると、

# for (int speid=0; speid<num_spe; speid) {
#     spe = spes[speid];
#     run_spe(spe, param, ...);
# }

# のようなコードを生成します
# ''', 'ctrump_runtime_spes[%s].spe_context'),

#     ('spe_runtime_name', 'SPEのインターフェースライブラリの種類',
#      '''SPEを扱うライブラリの種類を選択します''',
#      [('libspe2',SPE_LIBSPE2), ('libspe1',SPE_LIBSPE1)]),

]

translate_options_table = [
    ('buf_size', "ローカルバッファのサイズ", 
     '''使うローカルバッファのサイズをバイト単位で指定します。
小さすぎると正しく動作しません''', 16384),
    ('doublebuffering', 'ダブルバッファリングする',
     '''DMAのダブルバッファリングを行います。
メモリレイテンシを隠蔽できますが、一度に使えるローカルバッファのサイズが小さくなります''', True),
    ('get_align_128', 'GETを128byte境界に揃える',
     '''バッファを少し多めに使い、転送が128byte境界に揃うようにします(無効時は16に揃えます)
転送速度が速くなることがありますが、一度に使えるローカルバッファのサイズが小さくなります''', True),

    ('name_of_spe_program', 'プログラムオブジェクトの名前', 
'''プログラムオブジェクトの名前を指定します''',
     'spe_main'),

    ('parameter_var_name', 'パラメータ変数の名前',
     '''SPEに渡すパラメータの変数の名前を指定します''',
     'spe_param'),

#     ('ignore_unaligned_data', 'データが16byte境界に揃っていないケースを考慮しない',
# '''データ数が16byte境界に揃っていない場合の処理を省略します。
# データが16byte境界に揃っていない場合、バスエラーが発生するようになります''',
#      False)

#     ('ignore_small_size', 'データ数が少ない場合のケースを考慮しない',
# '''データ数がSPE数よりも少ない場合の処理を省略します''', 
#      False),

#     ('main', "mainを作る", '関数ではなくmainを作ります', False),
]

class EmitEnv:
    def __init__(self, abi, ea_type, aligned, ignore_unaligned_data, double_buffering):
        self.struct_list = []
        self.struct_pending = []
        self.variables = {}
        self.structs = {}
        self.all_block_iv = []
        self.all_scalar_iv = []
        self.abi = abi
        self.ea_type = ea_type
        self.align_size = aligned
        self.ignore_unalign = ignore_unaligned_data
        self.double_buffering = double_buffering

global_option = Option(global_options_table)
translate_option = Option(translate_options_table)

def align_ceil(v, align):
    v = v+(align-1)
    mod = v%align
    return v-mod

def align_mask_ceil(v, align, b):
    return b.paren(v+(align-1))&b.bcmpl(align-1)

def align_floor(v, align):
    mod = v%align
    return v-mod

def gen_ceil_div(l,r):
    return (l + r - 1) / r

def mul_if_not1(x,y):
    if isinstance(y,int):
        if y == 1:
            return x
        if y == 0:
            return 0
        return x * y
    if isinstance(x,int):
        if x == 0:
            return 0
        if x == 1:
            return y
        return y * x
    return x * y

def plus_if_not0(x,y):
    if isinstance(y,int):
        if y == 0:
            return x
        if y < 0:
            return x - -y
    if isinstance(x,int):
        if x == 0:
            return y
        return y+x
    return x+y

def minus_if_not0(x,y):
    if isinstance(y,int):
        if y == 0:
            return x
        if y < 0:
            return x + -y
    if isinstance(x,int):
        if x == 0:
            return -y
        return -y+x
    return x-y

def convert_cond(builder, exit_info, bound_expr):
    return builder.binary(exit_info.cmp_op,
                          builder.varref(exit_info.inductive), bound_expr)

def pointer_add(b, base, add):
    return b.cast(b.pointer_to(b.void), b.cast(b.uint,base) + add)

def append_typedefs(texpr, table):
    if (texpr.code == ctrump.TYPE_TYPEDEF_NAME or
        texpr.code == ctrump.TYPE_STRUCT):
        table[texpr] = True
    elif texpr.code == ctrump.TYPE_QUALIFIED:
        append_typedefs(texpr.unqualified_type, table)
    elif texpr.code == ctrump.TYPE_POINTER:
        append_typedefs(texpr.pointer_to, table)

def spe_in_param_member(have_spe_output, param, name):
    if have_spe_output:
        return param.member('in').member(name)
    else:
        return param.member(name)


def emit_unaligned_mfc(b, mod_var, len_var, align_size, mfc_func, dma_buffer, ea_type, ea_expr, dma_size, tag):
    return [
        b.assign(mod_var, b.band(b.paren(ea_expr), b.literal(align_size-1))),
        b.assign(len_var, align_mask_ceil(mod_var + dma_size, align_size, b)),

        mfc_func(dma_buffer,
                 b.binary(ctrump.EXPR_BIN_SUB, ea_expr, mod_var),
                 len_var,
                 tag, 0, 0),
        b.newline()
        ]

def emit_unaligned_mfc_mod(b, mod_var, len_var, align_size, mfc_func, dma_buffer, ea_type, ea_expr, dma_size, tag):
    return [
        b.assign(mod_var, b.band(b.cast(ea_type,ea_expr), b.literal(align_size-1))),
        b.assign(len_var, align_mask_ceil(mod_var + dma_size, align_size, b))]

def emit_unaligned_mfc_dma(b, mod_var, len_var, align_size, mfc_func, dma_buffer, ea_type, ea_expr, dma_size, tag):
    return [mfc_func(dma_buffer,
                     b.binary(ctrump.EXPR_BIN_SUB, ea_expr, mod_var),
                     len_var,
                     tag, 0, 0),
            b.newline()]

def emit_unaligned_mfc_scalar_mod(b, mod_var, len_var, align_size, mfc_func, dma_buffer, ea_type, ea_expr, dma_size, tag):
    return [
        b.assign(mod_var, b.band(b.cast(ea_type,ea_expr), b.literal(align_size-1)))
        ]
def emit_unaligned_mfc_scalar_dma(b, mod_var, len_var, align_size, mfc_func, dma_buffer, ea_type, ea_expr, dma_size, tag):
    return [mfc_func(dma_buffer,
                     b.binary(ctrump.EXPR_BIN_SUB, ea_expr, mod_var),
                     dma_size,
                     tag, 0, 0),
            b.newline()]





def name_of_subscript(subscript):
    name = ''

    if subscript.code == ctrump.LOOP_SUBSCRIPT_RECORD_MEMBER:
        name += '_%s'%subscript.member_name
    elif subscript.code == ctrump.LOOP_SUBSCRIPT_RECORD_MEMBER_TERMINAL:
        name += '_%s'%subscript.member_name

    if len(subscript.indices):
        for i in subscript.indices:
            if i.code == ctrump.LOOP_INDEX_INDUCTIVE:
                name += '_%s'%(i.var.name)
            elif i.code == ctrump.LOOP_INDEX_INVARIANT:
                name += '_%s'%(i.var.name)
            elif i.code == ctrump.LOOP_INDEX_POINTER_INC:
                name += '_ptrinc'

        if subscript.offset < 0:
            name += '_s%d'%-subscript.offset
        elif subscript.offset > 0:
            name += '_%d'%subscript.offset
    else:
        if subscript.offset < 0:
            name += '_s%d'%-subscript.offset
        elif subscript.offset > 0:
            name += '_%d'%subscript.offset
        else:
            name += '_0'

    return name

def memop_var_name_suffix(op):
    if op.chain:
        suffix = memop_var_name_suffix(op.chain)
    else:
        suffix = ''
    for j in op.subscripts:
        suffix = '%s%s'%(suffix, name_of_subscript(j))
    return suffix

def sequential_test_0(ops, loop_nest_level, seq_map):
    for i in ops:
        last_iv_level = None
        pointer_inc = False

        num_sub = len(i.subscripts)

        for j in range(0,num_sub):
            for k in i.subscripts[j].indices:
                if k.code == ctrump.LOOP_INDEX_INDUCTIVE:
                    last_iv_level = k.iv_level
                    last_iv_index = j
                    sequential_subscript = i.subscripts[j]
                    incr = k.incr
                    pointer_inc = False

                elif k.code == ctrump.LOOP_INDEX_INVARIANT:
                    pass

                elif k.code == ctrump.LOOP_INDEX_POINTER_INC:
                    last_iv_level = k.iv_level
                    last_iv_index = j
                    sequential_subscript = subscripts[j]
                    incr = k.incr
                    pointer_inc = True

        if last_iv_level == None:
            # invariant access
            i.is_sequential = False
            continue

        seq_map[i.loop_node.nest_level] = True
        i.is_sequential = (last_iv_level == loop_nest_level)
        i.sequential_subscript = sequential_subscript
        i.sequential_subscript_index = last_iv_index
        i.sequential_incr = incr
        i.is_pointer_inc = pointer_inc


def sequential_test(memop_node, seq_map):
    loop_nest_level = memop_node.loop_node.nest_level

    sequential_test_0(memop_node.ops, loop_nest_level, seq_map)

    for i in memop_node.children:
        sequential_test(i, seq_map)


def calc_memop_size_1(op, mem_size, emit_env):
    access_type = op.access_data_type()
    load_type = convert_ptr_to_ea(op.load_data_type(), emit_env.ea_type)

    access_sz = ctrump.calc_type_size(emit_env.abi, access_type)
    load_sz = ctrump.calc_type_size(emit_env.abi, load_type)

    if op.is_sequential:
        sz = load_sz * op.sequential_incr
        mem_size.seq_size += sz
    else:
        sz = access_sz
        mem_size.scalar_size += sz

    op.access_data_size = access_sz
    op.load_data_size = load_sz

    (range_min, range_max) = op.load_data_range()

    if sz < mem_size.min_size:
        mem_size.min_size = sz
    if sz > mem_size.max_size:
        mem_size.max_size = sz
        mem_size.max_range = (range_max - range_min)*sz

    mem_size.loop_unit_byte = lcm(mem_size.loop_unit_byte, sz)
    mem_size.num_buffer += 1

    d = range_max - range_min
    mem_size.range_size += align_ceil(sz * d, emit_env.align_size)

def calc_memop_size_0(memop_node, mem_size, emit_env):
    for i in memop_node.ops:
        calc_memop_size_1(i, mem_size, emit_env)

    for i in memop_node.children:
        calc_memop_size_0(i, mem_size, emit_env)

def calc_memop_size(memop_node, emit_env, buffer_size):
    class MemSize:
        def __init__(self, align_size):
            self.scalar_size = 0
            self.seq_size = 0
            self.num_buffer = 0
            self.min_size = MFC_MAX
            self.max_size = 0
            self.max_range = 0
            self.loop_unit_byte = align_size
            self.offset = 0
            self.scalar_offset = 0
            self.range_size = 0
    align_size = emit_env.align_size
    memsize = MemSize(align_size)

    calc_memop_size_0(memop_node, memsize, emit_env)

    sequential_buffer_size = buffer_size - align_ceil(memsize.scalar_size, align_size)

    align_padding = align_size * 2
    padding_size = memsize.num_buffer * (align_padding + align_size) + memsize.range_size

    if emit_env.double_buffering:
        available_buffer_size = align_floor(sequential_buffer_size/2 - padding_size, align_size)
        second_buffer_start = align_floor(sequential_buffer_size/2, align_size)
        memsize.second_buffer_start = second_buffer_start
    else:
        available_buffer_size = sequential_buffer_size - padding_size
        second_buffer_start = 0

    # test toplevel operation for SPE division.

    have_seq_access = False

    for i in memop_node.ops:
        if i.is_sequential:
            have_seq_access = True

    loop_unit_byte = memsize.loop_unit_byte
    min_size = memsize.min_size
    max_size = memsize.max_size
    max_range = memsize.max_range
    seq_size = memsize.seq_size

    if have_seq_access:
        spe_dispatch_unit = loop_unit_byte/min_size
    else:
        spe_dispatch_unit = 1

    if seq_size == 0:
        # fixme
        block_elem_count = 1
        spe_dispatch_unit = 1
    else:
        block_elem_count = available_buffer_size / seq_size

    block_elem_count = align_floor(block_elem_count, spe_dispatch_unit)

    if block_elem_count*max_size > (MFC_MAX-align_padding-max_range):
        block_elem_count = align_floor((MFC_MAX-align_padding-max_range)/max_size, spe_dispatch_unit)

    memsize.block_elem_count = block_elem_count
    memsize.available_buffer_size = available_buffer_size
    memsize.second_buffer_start = second_buffer_start
    memsize.spe_dispatch_unit = spe_dispatch_unit
    memsize.align_padding = align_padding

    return memsize

def convert_ptr_to_ea(ptr_type, ea_type):
    if ptr_type.code == ctrump.TYPE_POINTER:
        return convert_ptr_to_ea(ea_type, ea_type)
    return ptr_type

def get_loop_symbol(loop_node):
    (ind, reach, incr) = EI.get_loop_counter(loop_node.exit_info)
    return ind.name

def emit_decl_if_not_declared(decls, b, t, name, env):
    if not name in env:
        decls.append(b.decl(t, name))

def decl_subscript(b, decls, subscripts, env):
    for i in subscripts:
        for j in i.indices:
            if j.code == ctrump.LOOP_INDEX_INDUCTIVE:
                if not j.var.name in env:
                    emit_decl_if_not_declared(decls, b, b.int_, j.var.name, env)
                    env[j.var.name] = True

def decl_memop_buffer_ops(decls, b, ops, mem_size, loop_symbol,
                          block_elem_count, emit_env):
    s = b.scope

    ea_type = emit_env.ea_type
    abi = emit_env.abi
    variables = emit_env.variables
    align_size = emit_env.align_size
    double_buffering = emit_env.double_buffering

    for i in ops:
        access_data_type = i.access_data_type()
        load_data_type = i.load_data_type()
        scalar_access_type = convert_ptr_to_ea(access_data_type, ea_type)
        scalar_elem_sz = ctrump.calc_type_size(abi, access_data_type)
        vector_access_type = convert_ptr_to_ea(load_data_type, ea_type)
        vector_elem_sz = ctrump.calc_type_size(abi, load_data_type)
        array_var = i.array.var

        subscripts = i.subscripts
        seq_buffer = None

        suffix = ''

        decl_subscript(b, decls, subscripts, variables)

        suffix = memop_var_name_suffix(i)

        buffer_type = b.pointer_to(b.uchar)
        mem_size.offset += align_size # for padding

        (range_min, range_max) = i.load_data_range()
        d = range_max - range_min
        range_size = vector_elem_sz * d

        if i.is_sequential:
            buffer_init = b.cast(buffer_type, s.spe_buffer + mem_size.offset)
            elem_sz = vector_elem_sz
            sz = vector_elem_sz * i.sequential_incr
            mem_size.offset = align_ceil(mem_size.offset + sz, align_size)
            access_type = ctrump.spe.convert_type_ppe_to_spe(b, vector_access_type, emit_env.structs,
                                                             emit_env.struct_pending, emit_env.struct_list,
                                                             emit_env.abi)

            mem_size.offset += align_ceil(block_elem_count*sz, align_size)
        else:
            buffer_init = b.cast(buffer_type, s.spe_buffer + mem_size.scalar_offset)
            elem_sz = scalar_elem_sz
            sz = scalar_elem_sz + range_size
            mem_size.scalar_offset = align_ceil(mem_size.scalar_offset + sz, align_size)
            access_type = ctrump.spe.convert_type_ppe_to_spe(b, scalar_access_type, emit_env.structs,
                                                             emit_env.struct_pending, emit_env.struct_list,
                                                             emit_env.abi)
            load_data_type = ctrump.spe.convert_type_ppe_to_spe(b, load_data_type, emit_env.structs,
                                                                emit_env.struct_pending,
                                                                emit_env.struct_list, emit_env.abi)

            mem_size.scalar_offset = align_ceil(elem_sz, align_size)

        mem_size.offset += align_ceil(range_size, align_size)
        loop_pointer_name = '%s%s'%(array_var.name, suffix)

        if loop_pointer_name in variables:
            i.buffer_var = variables[loop_pointer_name]
        else:
            buffer_name = '%s%s_base'%(array_var.name,suffix)
            mod_var_name = '%s%s_mod'%(array_var.name,suffix)
            len_var_name = '%s%s_len'%(array_var.name,suffix)

            if double_buffering:
                decls.append([
                        b.decl(b.array_of(buffer_type,2), buffer_name),
                        b.assign(s[buffer_name][0], buffer_init),
                        b.assign(s[buffer_name][1], buffer_init + mem_size.secondary_offset),
                        b.decl(b.array_of(b.int_,2), mod_var_name),
                        b.decl(b.array_of(b.int_,2), len_var_name)])
            else:
                decls.append([
                        b.decl(buffer_type, buffer_name,
                               init=buffer_init),
                        b.decl(b.int_, mod_var_name),
                        b.decl(b.int_, len_var_name)])

            decls.append(b.decl(b.pointer_to(load_data_type), loop_pointer_name))
            var = s[loop_pointer_name]
            i.loop_pointer = var
            i.buffer = s[buffer_name]
            i.mod_var = s[mod_var_name]
            i.len_var = s[len_var_name]

            variables[loop_pointer_name] = i

            i.buffer_var = i


def decl_memop_buffer(decls, b, memop_node, mem_size,  block_elem_count, emit_env):
    s = b.scope
    loop_symbol = get_loop_symbol(memop_node.loop_node)

    decl_memop_buffer_ops(decls, b, memop_node.ops, mem_size, loop_symbol,
                          block_elem_count, emit_env)

    for i in memop_node.children:
        decl_memop_buffer(decls, b, i, mem_size, block_elem_count, emit_env)

def index_list_iv_level(indices):
    iv_level = None
    for i in indices:
        if (i.code == ctrump.LOOP_INDEX_INDUCTIVE or
            i.code == ctrump.LOOP_INDEX_POINTER_INC):
            iv_level = i.iv_level

    return iv_level


def subscript_offset(b, sub, byte_offset_expr, elem_offset_expr, is_vector, abi):
    if (sub.code == ctrump.LOOP_SUBSCRIPT_COEF_ARRAYSIZE or
        sub.code == ctrump.LOOP_SUBSCRIPT_COEF_CONSTANT):
        elem_offset_expr = mul_if_not1(sub.array_size_coef, elem_offset_expr)

    elif sub.code == ctrump.LOOP_SUBSCRIPT_COEF_SCALE:
        elem_offset_expr = mul_if_not1(b.varref(sub.scale_array_coef), elem_offset_expr)

    elif (sub.code == ctrump.LOOP_SUBSCRIPT_RECORD_MEMBER or
          sub.code == ctrump.LOOP_SUBSCRIPT_RECORD_MEMBER_TERMINAL):
        if not is_vector:
            field_offset = ctrump.struct_field_offset(abi, sub.record_type, sub.member_name)
            byte_offset_expr = plus_if_not0(field_offset, byte_offset_expr)
    elif sub.code == ctrump.LOOP_SUBSCRIPT_COEF_TERMINAL:
        pass
    elif sub.code == ctrump.LOOP_SUBSCRIPT_LOAD_RECORD:
        pass
    else:
        raise Exception('unkonwn subscript %s'%ctrump.loop_subscript_code_string_table[sub.code])

    return (byte_offset_expr, elem_offset_expr)

def index_list_scalar_access(b, indices, start_offset, loop_top_level):
    s = b.scope
    offset_expr = 0

    for i in indices:
        if i.code == ctrump.LOOP_INDEX_INDUCTIVE:
            if i.iv_level == loop_top_level:
                offset_expr = plus_if_not0(offset_expr,
                                           s[i.var.name] + start_offset)
            else:
                offset_expr = plus_if_not0(offset_expr, s[i.var.var.name])


        elif i.code == ctrump.LOOP_INDEX_INVARIANT:
            offset_expr = plus_if_not0(offset_expr, s[i.invariant.name])

        elif i.code == ctrump.LOOP_INDEX_POINTER_INC:
            # do nothing
            pass 

    return offset_expr

def subscript_list_scalar_access(b, subscripts, start_offset, loop_top_level, abi):
    byte_offset_expr = 0
    elem_offset_expr = 0
    for j in subscripts:
        index_offset = index_list_scalar_access(b, j.indices, start_offset, loop_top_level)
        elem_offset_expr = plus_if_not0(index_offset, elem_offset_expr)
        elem_offset_expr = plus_if_not0(elem_offset_expr, j.offset)

        (byte_offset_expr, elem_offset_expr) = subscript_offset(b, j, byte_offset_expr, elem_offset_expr, False, abi)

    return (byte_offset_expr, elem_offset_expr)

def index_list_vector_access(b, indices, start_offset, loop_top_level, access_level, block_size,
                             index_offset_map, is_first_get, seq_map):
    s = b.scope
    offset_expr = 0
    size_coef = 1

    for i in indices:
        if i.code == ctrump.LOOP_INDEX_INDUCTIVE:
            if is_first_get and i.iv_level == access_level:
                incr = i.incr
                iv_level = i.iv_level
                size_coef = mul_if_not1(size_coef, incr)

                if iv_level in seq_map:
                    block_var_name = 'block_%s'%i.var.name
                    index_offset = 0
                    if iv_level in index_offset_map:
                        index_offset = index_offset_map[iv_level]

                    if iv_level == access_level:
                        if iv_level == loop_top_level:
                            offset_expr = plus_if_not0(offset_expr,
                                                       start_offset)
                        else:
                            pass
                    else:
                        if iv_level == loop_top_level:
                            offset_expr = plus_if_not0(offset_expr,
                                                       start_offset)
                        else:
                            pass

            else:
                incr = i.incr
                iv_level = i.iv_level
                size_coef = mul_if_not1(size_coef, incr)

                if iv_level in seq_map:
                    block_var_name = 'block_%s'%i.var.name
                    index_offset = 0
                    if iv_level in index_offset_map:
                        index_offset = index_offset_map[iv_level]

                    if iv_level == access_level:
                        if iv_level == loop_top_level:
                            offset_expr = plus_if_not0(offset_expr,
                                                       plus_if_not0(s[block_var_name],index_offset)*block_size + start_offset)
                        else:
                            offset_expr = plus_if_not0(offset_expr,
                                                       plus_if_not0(s[block_var_name],index_offset)*block_size)
                    else:
                        if iv_level == loop_top_level:
                            offset_expr = plus_if_not0(offset_expr,
                                                       s[i.var.name] + plus_if_not0(s[block_var_name],index_offset)*block_size + start_offset)
                        else:
                            offset_expr = plus_if_not0(offset_expr,
                                                       s[i.var.name] + plus_if_not0(s[block_var_name],index_offset)*block_size)

                else:
                    if iv_level == loop_top_level:
                        offset_expr = plus_if_not0(offset_expr,
                                                   mul_if_not1(s[i.var.name], incr) + start_offset)
                    else:
                        offset_expr = plus_if_not0(offset_expr,
                                                   mul_if_not1(s[i.var.name], incr))

        elif i.code == ctrump.LOOP_INDEX_INVARIANT:
            offset_expr = plus_if_not0(offset_expr, s[i.invariant.name])

        elif i.code == ctrump.LOOP_INDEX_POINTER_INC:
            # do nothing
            pass

    return (offset_expr, size_coef)


def subscript_list_vector_access(b, subscripts, start_offset, loop_top_level,
                                 access_level, range_min, range_max,
                                 block_size, index_offset_map, is_first_get,
                                 abi, seq_map):
    byte_offset_expr = 0
    elem_offset_expr = 0
    size_coef = 1

    for j in subscripts:
        (index_offset, index_coef) = index_list_vector_access(b, j.indices, start_offset, loop_top_level,
                                                              access_level, block_size, index_offset_map,
                                                              is_first_get, seq_map)
        size_coef = mul_if_not1(size_coef, index_coef)
        elem_offset_expr = plus_if_not0(index_offset, elem_offset_expr)

        (byte_offset_expr, elem_offset_expr) = subscript_offset(b, j, byte_offset_expr, elem_offset_expr, True, abi)

    return (byte_offset_expr, elem_offset_expr, size_coef)

def byte_offset_ptr_ref(b, ret_type, var, offset):
    char_type = b.uchar
    return b.ptr_ref(b.cast(ret_type, b.cast(b.pointer_to(char_type), var) + offset))

def byte_offset_ptr_add(b, ret_type, var, offset):
    char_type = b.uchar
    return b.cast(ret_type, b.cast(b.pointer_to(char_type), var) + offset)


def emit_memory_access(b, memop,
                       align_size, mfc_ops, emit_env,
                       start_offset, top_loop_nest_level, mem_access_emitted):
    scalar_dma_get_stmts = []
    scalar_dma_put_stmts = []
    scalar_buf_addr_set_stmts = []
    vector_load_ops = []
    vector_store_ops = []
    double_buffering = emit_env.double_buffering
    ea_type = emit_env.ea_type
    abi = emit_env.abi
    ignore_unalign = emit_env.ignore_unalign

    s = b.scope

    if memop in mem_access_emitted:
        return

    subscripts = memop.subscripts

    if memop.chain:
        emit_memory_access(b, memop.chain, align_size, mfc_ops, emit_env,
                           start_offset, top_loop_nest_level, mem_access_emitted)
        ea_base_expr = memop.chain.scalar_access_expr
    else:
        ea_base_expr = s['ea_%s'%str(memop.array.var.name)]

    last_iv_level = None

    sub = subscripts[memop.load_data_sub_offset()]

    load_type = convert_ptr_to_ea(sub.load_type, ea_type)
    load_size = b.calc_type_size(abi, load_type)
    aligned_load_size = align_ceil(load_size, align_size)

    if memop.is_sequential:
        if memop.load_store == memop.LOAD:
            vector_load_ops.append((load_type, memop, ea_base_expr, subscripts))
        elif memop.load_store == memop.STORE:
            vector_store_ops.append((load_type, memop, ea_base_expr, subscripts))

        ref_expr = build_array_op_ref_expr(b, memop, double_buffering, ignore_unalign, memop.offset_list)
        memop.scalar_access_expr = ref_expr
    else:
        (byte_offset,elem_offset) = subscript_list_scalar_access(b, subscripts,
                                                                 top_loop_nest_level, start_offset, abi)

        var = memop.buffer_var.buffer
        mod_var = memop.buffer_var.mod_var
        len_var = memop.buffer_var.len_var

        (range_min, range_max) = memop.load_data_range()
        offset = plus_if_not0(elem_offset, range_min)

        size_expr = b.literal(load_size)

        ea_expr = plus_if_not0(b.cast(b.puchar,ea_base_expr),
                               plus_if_not0(mul_if_not1(size_expr,offset), byte_offset))

        if double_buffering:
            scalar_dma_get_stmts.append([
                    emit_unaligned_mfc_scalar_mod(b, mod_var[0], len_var[0], align_size,
                                                  mfc_ops.get, var[0], ea_type,
                                                  ea_expr,
                                                  aligned_load_size, 0)
                    ])
            scalar_buf_addr_set_stmts.append([
                    b.assign(memop.buffer_var.loop_pointer, var[0] + mod_var[0])
                    ])
        else:
            scalar_dma_get_stmts.append([
                    emit_unaligned_mfc_scalar_mod(b, mod_var, len_var, align_size,
                                                  mfc_ops.get, var, ea_type,
                                                  ea_expr,
                                                  aligned_load_size, 0)
                    ])
            scalar_buf_addr_set_stmts.append([
                    b.assign(memop.buffer_var.loop_pointer, var + mod_var)
                    ])

        if memop.load_store == memop.LOAD:
            s = scalar_dma_get_stmts
            op = mfc_ops.get
            dma_size = aligned_load_size

            if double_buffering:
                local_buffer = var[0]
                s.append([
                    emit_unaligned_mfc_scalar_dma(b, mod_var[0], len_var[0], align_size,
                                                  op, local_buffer, ea_type,
                                                  ea_expr,
                                                  dma_size, 0)
                    ])
                access_expr = var[0] + mod_var[0]
            else:
                local_buffer = var
                s.append([
                    emit_unaligned_mfc_scalar_dma(b, mod_var, len_var, align_size,
                                                  op, local_buffer, ea_type,
                                                  ea_expr,
                                                  dma_size, 0)
                    ])
                access_expr = var + mod_var

        else:
            s = scalar_dma_put_stmts
            op = mfc_ops.put_unaligned
            dma_size = load_size

            local_buffer = memop.buffer_var.loop_pointer

            s.append([
                op(local_buffer, ea_expr, load_size, 0, 0, 0)
                ])

            if double_buffering:
                access_expr = var[0] + mod_var[0]
            else:
                access_expr = var + mod_var

        s.append([
                mfc_ops.write_tag_mask(1),
                mfc_ops.read_tag_status_all()])

        memop.scalar_access_expr = b.ptr_ref(b.cast(b.pointer_to(load_type), access_expr))

    memop.scalar_dma_get_stmts = scalar_dma_get_stmts
    memop.scalar_dma_put_stmts = scalar_dma_put_stmts
    memop.scalar_buf_addr_set_stmts = scalar_buf_addr_set_stmts
    memop.vector_load_ops = vector_load_ops
    memop.vector_store_ops = vector_store_ops

    mem_access_emitted[memop] = memop

# returns declaration stmts
# update memop
def emit_buffer_declaration(b, memsize,
                            buffer_name, buffer_size, memop_node, invariant_memops,
                            emit_env):
    global_decls = []
    local_decls = []

    all_buffer_type = b.array_of(b.uchar, buffer_size)
    buffer_decl = b.decl(all_buffer_type, buffer_name, stor_class=STOR_CLASS_STATIC, align=128)

    global_decls.append(buffer_decl)

    loop_unit_byte = memsize.loop_unit_byte
    min_size = memsize.min_size
    max_size = memsize.max_size
    max_range = memsize.max_range
    seq_size = memsize.seq_size
    block_elem_count = memsize.block_elem_count
    align_padding = memsize.align_padding
    spe_dispatch_unit = memsize.spe_dispatch_unit

    if block_elem_count <= 0:
        raise Exception("too large data size")

    decl_memop_buffer_ops(local_decls, b, invariant_memops, memsize, '', memsize.block_elem_count, emit_env)
    decl_memop_buffer(local_decls, b, memop_node, memsize, memsize.block_elem_count, emit_env)

    return (global_decls, local_decls)

def loop_blocking(builder, loop_node, all_loop_count, loop_stmt, block_size, ops, emit_env, double_buffer_dma_get):
    double_buffering = emit_env.double_buffering
    b = builder
    s = b.scope

    loop_symbol = get_loop_symbol(loop_node)
    exit_info = loop_node.exit_info

    s = builder.scope

    init = loop_stmt.init
    cond = loop_stmt.cond
    iter = loop_stmt.iter
    body = loop_stmt.body

    before_block_stmts = []

    if double_buffering:
        bufside = s['bufside_%s'%loop_symbol]

    ptr_inc_var = PtrIncVarEnv()
    iv_list = []

    for i in ops:
        iv_list += i.extract_iv(ptr_inc_var)
        emit_env.all_block_iv += iv_list

    block_iv = []
    for incr in ptr_inc_var.incr_table:
        block_iv.append((builder.int_, 'block_incptr_%d'%incr, None))

    iv_emitted = {}
    for iv in iv_list:
        if not iv.var in iv_emitted:
            block_iv.append((iv.var.type, 'block_%s'%str(iv.var.name), iv.var.name, iv.reach_at_loop_entry))
            iv_emitted[iv.var] = True

    block_iv_decls = []

    for (type,name,orig_name,loop_entry_definition) in block_iv:
        iv_var = s[orig_name]

        block_initial_val = iv_var/block_size

        entry_val = None

        if loop_entry_definition and loop_entry_definition.code == ctrump.PDG_VALUE_EXPR:
            entry_val = ctrump.fold_const(loop_entry_definition.val)
            if None != entry_val:
                block_initial_val = iv_var/block_size
            else:
                block_initial_val = builder.div(iv_var, block_size)

        if id(0) == id(entry_val):
            block_iv_decls.append(builder.decl(type, name, init=0))
        else:
            init_name = '%s_init'%name
            block_iv_decls.append(builder.decl(type, init_name, init=block_initial_val))
            block_iv_decls.append(builder.decl(type, name, init=s[init_name]))

    empty_expr = builder.empty_expr()

    block_for_init = empty_expr

    (loop_counter, iv_loop_entry, loop_counter_incr) = EI.get_loop_counter(exit_info)
    loop_counter_name = loop_counter.name

    num_block_count = gen_ceil_div(all_loop_count,block_size)
    block_counter_name = 'block_%s'%str(loop_counter_name)
    block_loop_num_name = 'block_count_%s'%str(loop_counter_name)

    if not loop_counter in iv_emitted:
        block_iv_decls.append(builder.decl(loop_counter.type,
                                           block_counter_name,
                                           init=0))

    iv_var = s[loop_counter.name]
    iv_block_var = s['block_%s'%loop_counter.name]

    block_initial_val = iv_var/block_size

    first_iv_init = None
    inner_for_init = empty_expr

    if iv_loop_entry.code == ctrump.PDG_VALUE_EXPR:
        entry_val = ctrump.fold_const(iv_loop_entry.val)
        if (None != entry_val) and entry_val == 0:
            first_iv_init = []
            inner_for_init = b.assign(iv_var, 0)
            block_for_init = b.assign(iv_block_var, 0)

    if first_iv_init == None:
        block_iv_decls.append(b.decl(iv_var.type, '%s_start'%iv_var.name, init=iv_var))

        start_var = s['%s_start'%iv_var.name]

        first_iv_init = [
            b.if_ (iv_block_var != s['block_%s_init'%loop_counter.name],
                   b.assign(iv_var, 0)),
            b.assign(start_var, iv_var)
            ]

        for i in ops:
            i.loop_counter_offset = start_var
    else:
        for i in ops:
            i.loop_counter_offset = None

    block_iv_decls.append(builder.decl(loop_counter.type,
                                       block_loop_num_name,
                                       init=num_block_count))

    block_for_cond = builder.binary(exit_info.cmp_op, 
                                    s[block_counter_name],
                                    s[block_loop_num_name])
    block_for_iter = empty_expr

    bound_var = EI.build_bound_var(builder, block_iv_decls,
                                   exit_info, 'loop_num', block_size)

    if double_buffering:
        next_bound_var_name = '%s_next'%bound_var.name
        block_iv_decls.append(b.decl(b.int_, next_bound_var_name, init=0))
        next_bound_var = s[next_bound_var_name]
        calc_next_len = b.if_(s[block_counter_name] == s[block_loop_num_name]-2,
                              b.comp(b.assign(next_bound_var, (all_loop_count-1)%block_size+1)))
        not_last_loop = b.comp(b.assign(next_bound_var, block_size),
                               calc_next_len,
                               double_buffer_dma_get)
    else:
        not_last_loop = None

    block_head = [
        b.assign(bound_var, block_size),
        b.if_ (s[block_counter_name] == s[block_loop_num_name]-1,
               b.comp(b.assign(bound_var, (all_loop_count-1)%block_size+1)),
               else_body = not_last_loop),
        first_iv_init,
        b.newline(),
        ]

    inner_cond = builder.binary(exit_info.cmp_op, 
                                builder.varref(exit_info.inductive),
                                mul_if_not1(bound_var, loop_counter_incr))

    block_iv_decls.append(b.newline())

    block_foot = []
    for (type,name,orig_name,pdg) in block_iv:
        block_foot.append(b.postinc(s[name]))

    if double_buffering:
        block_foot.append(b.assign(bufside , bufside^1))

    return (block_iv_decls, loop_counter_name, bound_var, s[block_counter_name],
            before_block_stmts,
            block_for_init, block_for_cond, block_for_iter, block_head, block_foot,
            inner_for_init, inner_cond ,iter, body)

def offload_loop(b, loop_node, init, cond, iter, body, scalar_get_stmts, scalar_put_stmts):
    return b.for_(init, cond, iter, b.comp(scalar_get_stmts, body, scalar_put_stmts))

def  build_array_ref(b, array_var, sub_sub, offset_list):
    expr = array_var

    for (sub, (off,range_min,range_max)) in zip(sub_sub, offset_list):
        if isinstance(off,int):
            offset_int = off
            offset_tag = None
        else:
            offset_int = 0
            offset_tag = off

        if sub.code == ctrump.LOOP_SUBSCRIPT_COEF_TERMINAL:
            sub_off = offset_int
            if len(sub.indices) != 0:
                sub_off = plus_if_not0(b.varref(sub.indices[0].var), sub_off)
            expr = expr[sub_off]
        elif (sub.code == ctrump.LOOP_SUBSCRIPT_COEF_ARRAYSIZE or
              sub.code == ctrump.LOOP_SUBSCRIPT_COEF_CONSTANT or
              sub.code == ctrump.LOOP_SUBSCRIPT_COEF_SCALE):
            pass # address was already generated as offset
        elif sub.code == ctrump.LOOP_SUBSCRIPT_RECORD_MEMBER:
            expr = expr.member(sub.member_name)
        elif sub.code == ctrump.LOOP_SUBSCRIPT_RECORD_MEMBER_TERMINAL:
            if offset_tag:
                expr = expr.member(offset_tag)
            else:
                expr = expr.member(sub.member_name)
        elif sub.code == ctrump.LOOP_SUBSCRIPT_LOAD_RECORD:
            sub_off = offset_int
            if len(sub.indices) != 0:
                sub_off = plus_if_not0(b.varref(sub.indices[0].var), sub_off)
            expr = expr[sub_off]
        else:
            raise NotImplementedError('unknown subscript code "%s"'%ctrump.loop_subscript_code_string_table[sub.code])

    return expr

def build_array_op_ref_expr(b, array_op, double_buffering, ignore_unalign, offset_list):
    if array_op.is_sequential:
        sub_sub = array_op.subscripts[array_op.sequential_subscript_index:]
        offset_list = offset_list[array_op.sequential_subscript_index:]

        if array_op.sequential_subscript.indices[0].code == ctrump.LOOP_INDEX_INDUCTIVE:
            spe_array_var = array_op.buffer_var.loop_pointer
            new_expr = build_array_ref(b, spe_array_var, sub_sub, offset_list)
        else:
            raise Exception('sequential access with "%s"'%
                            ctrump.loop_index_code_string_table[array_op.sequential_subscript.indices[0].code])
    else:
        sub_sub = array_op.subscripts
        spe_array_var = array_op.buffer_var.loop_pointer
        new_expr = build_array_ref(b, spe_array_var, sub_sub, offset_list)

    return new_expr


def replace_array_ref_expr(b, array_op, double_buffering, ignore_unalign):
    s = b.scope

    for (offset,expr) in array_op.update_expr_list:
        new_expr = build_array_op_ref_expr(b, array_op, double_buffering, ignore_unalign, offset)
        if expr:
            expr.replace(b.build_expr(new_expr))


def gather_buffer_name_1(ops, ptrs, emitted, ea_type):
    for op in ops:
        var = op.array.var
        if not var.name in emitted:
            original_texpr = var.type
            pointer_texpr = ctrump.type_apply_unary_pointer_conversion(original_texpr)
            ptrs.append((original_texpr, ea_type, var))
            emitted[var.name] = True

def gather_buffer_name_0(node, ptrs, emitted, ea_type):
    gather_buffer_name_1(node.ops, ptrs, emitted, ea_type)
    for i in node.children:
        gather_buffer_name_0(i, ptrs, emitted, ea_type)

def gather_buffer_name(memory_operation, ptrs, emitted, ea_type):
    gather_buffer_name_1(memory_operation.invariants, ptrs, emitted, ea_type)
    gather_buffer_name_0(memory_operation.tree, ptrs, emitted, ea_type)


def emit_loop_node(b, mem_size, memop_node, emit_env, 
                   mfc_ops, all_loop_count, start_offset, top_loop_nest_level, mem_access_emitted, seq_map):
    ea_type = emit_env.ea_type
    double_buffering = emit_env.double_buffering
    ignore_unalign = emit_env.ignore_unalign
    align_size = emit_env.align_size
    abi = emit_env.abi
    ret_stmts = []
    loop_node = memop_node.loop_node
    exit_info = loop_node.exit_info
    loop_cfg_info = loop_node.cfg_info
    loop_stmt = loop_cfg_info.loop_stmt

    if not all_loop_count:
        all_loop_count = EI.build_bound_expr(b, exit_info) 

    ops = memop_node.ops

    loop_symbol = get_loop_symbol(loop_node)

    scalar_get_stmts = []
    scalar_put_stmts = []
    scalar_buf_addr_set_stmts = []
    vector_load_ops = []
    vector_store_ops = []

    if not loop_stmt.code == ctrump.STMT_FOR:
        raise ('not "for" loop')

    for i in ops:
        emit_memory_access(b, i,
                           align_size, mfc_ops, emit_env,
                           start_offset, top_loop_nest_level, mem_access_emitted)

    for i in ops:
        scalar_get_stmts += i.scalar_dma_get_stmts
        scalar_put_stmts += i.scalar_dma_put_stmts
        scalar_buf_addr_set_stmts += i.scalar_buf_addr_set_stmts

    for i in ops:
        vector_load_ops += i.vector_load_ops
        vector_store_ops += i.vector_store_ops

    (loop_counter, iv_loop_entry, loop_counter_incr) = EI.get_loop_counter(exit_info)

    s = b.scope
    iv_var = s[loop_counter.name]

    first_iv_init = None
    if iv_loop_entry.code == ctrump.PDG_VALUE_EXPR:
        entry_val = ctrump.fold_const(iv_loop_entry.val)
        if (None != entry_val) and entry_val == 0:
            first_iv_init = [b.assign(iv_var, 0) ]

    if first_iv_init == None:
        first_iv_init = [
            b.if_(iv_var < s.spe_param.member('loop_count')*s.spe_id,
                  b.assign(iv_var , 0),
                  b.assign(iv_var, iv_var - s.spe_param.member('loop_count')*s.spe_id))
            ]

    if (len(vector_load_ops) != 0) or (len(vector_store_ops) != 0):
        # require loop blocking to get sequential data

        block_size = mem_size.block_elem_count

        bufside_decls = []

        if double_buffering:
            bufside_decls.append(b.decl(b.int_, 'bufside_%s'%loop_symbol, init=0))
            bufside = b.scope['bufside_%s'%loop_symbol]

        double_buffer_dma_get = []

        (decls, loop_symbol, loop_bound_var, block_ind_var,
         before_block_stmts,
         block_init, block_cond, block_iter, block_body, block_foot,
         inner_init, inner_cond, inner_iter, inner_body) = loop_blocking(b, loop_node, all_loop_count,
                                                                         loop_stmt, block_size, ops, emit_env,
                                                                         double_buffer_dma_get)

        inner_loop = offload_loop(b, loop_node, inner_init, inner_cond, inner_iter, inner_body,
                                  [scalar_get_stmts, scalar_buf_addr_set_stmts], scalar_put_stmts)

        decls.append(bufside_decls)

        dma_get_stmts = []
        mfc_mod_stmt_list = []
        dma_put_stmts = []
        double_buffer_first_get = []

        adjust_buffer_stmt = []

        get_emitted = {}
        put_emitted = {}
        adjust_emitted = {}

        index_offset_map = {}
        index_offset_map_first_get = {}

        if double_buffering:
            index_offset_map[memop_node.loop_node.nest_level] = 1

        def vector_dma_op(op):
            (load_type, memop, ea_expr, offset_subscripts) = op
            (range_min, range_max) = memop.load_data_range()
            d = range_max - range_min

            ae = plus_if_not0(ea_expr, range_min*memop.load_data_size)

            (block_byte_offset, block_elem_offset, size_coef) = subscript_list_vector_access(b,
                                                                                             offset_subscripts,
                                                                                             start_offset,
                                                                                             top_loop_nest_level, 
                                                                                             memop.loop_node.nest_level,
                                                                                             range_min,
                                                                                             range_max,
                                                                                             mem_size.block_elem_count,
                                                                                             {},
                                                                                             False,
                                                                                             abi,
                                                                                             seq_map)

            (first_block_byte_offset, first_block_elem_offset, size_coef) = subscript_list_vector_access(b,
                                                                                                         offset_subscripts,
                                                                                                         start_offset,
                                                                                                         top_loop_nest_level, 
                                                                                                         memop.loop_node.nest_level,
                                                                                                         range_min,
                                                                                                         range_max,
                                                                                                         mem_size.block_elem_count,
                                                                                                         {},
                                                                                                         True,
                                                                                                         abi,
                                                                                                         seq_map)

            (block_byte_offset_get, block_elem_offset_get, size_coef) = subscript_list_vector_access(b,
                                                                                                     offset_subscripts,
                                                                                                     start_offset,
                                                                                                     top_loop_nest_level, 
                                                                                                     memop.loop_node.nest_level,
                                                                                                     range_min,
                                                                                                     range_max,
                                                                                                     mem_size.block_elem_count,
                                                                                                     index_offset_map,
                                                                                                     False,
                                                                                                     abi,
                                                                                                     seq_map)

            loop_pointer = memop.buffer_var.loop_pointer # fixme : may remove by cse
            buffer = memop.buffer_var.buffer

            is_partial_store = memop.is_partial_store()

            memop_size = b.literal(memop.load_data_size)
            block_off_put = mul_if_not1(plus_if_not0(memop_size*(block_elem_offset), block_byte_offset), size_coef)
            block_off_first = mul_if_not1(plus_if_not0(memop_size*first_block_elem_offset, first_block_byte_offset), size_coef)

            put_off = 0

            if memop.loop_counter_offset:
                put_off = memop_size*memop.loop_counter_offset

            if double_buffering:
                block_off_get = mul_if_not1(plus_if_not0(memop_size*(block_elem_offset_get), block_byte_offset_get), size_coef)
                next_loop_bound_var = s['%s_next'%loop_bound_var.name]
                next_size = plus_if_not0(next_loop_bound_var, d) * memop.load_data_size
                next_size = mul_if_not1(next_size, size_coef)
            else:
                block_off_get = block_off_put

            current_size = plus_if_not0(loop_bound_var, d) * memop.load_data_size
            current_size = mul_if_not1(current_size, size_coef)

            if memop.load_store == memop.LOAD:
                mfc_func = mfc_ops.get

                if double_buffering:
                    mfc_stmt_list = double_buffer_dma_get
                    bufside_expr_get = bufside^1
                    bufside_expr_dma = bufside^1
                    block_off_get = block_off_get
                    block_off_dma = block_off_get
                    get_size = next_size
                    dma_size = next_size
                    dma_off = 0
                else:
                    mfc_stmt_list = dma_get_stmts
                    block_off_dma = block_off_get
                    get_size = current_size
                    dma_size = current_size
                    dma_off = 0

                mfc_emitted = get_emitted
                put=False
            else:
                mfc_func = mfc_ops.put_unaligned
                mfc_stmt_list = dma_put_stmts
                mfc_emitted = put_emitted
                if double_buffering:
                    bufside_expr_get = bufside^1
                    bufside_expr_dma = bufside
                    block_off_get = block_off_get
                    block_off_dma = block_off_put
                    get_size = next_size
                    dma_size = current_size
                    dma_off = put_off
                else:
                    block_off_dma = block_off_get
                    get_size = current_size
                    dma_size = current_size
                    dma_off = put_off

                put=True
                block_off = block_off_put

            if double_buffering:
                tag_expr_dma = bufside_expr_dma+loop_node.nest_level*2
                tag_expr_get = bufside_expr_get+loop_node.nest_level*2
            else:
                tag_expr = 0

            if not buffer in mfc_emitted:
                mfc_emitted[buffer] = True
                pin0 = plus_if_not0
                min0 = minus_if_not0

                if double_buffering:
                    if ignore_unalign:
                        raise Exception('fixme:aligned-doublebuffering')
                        mfc_stmt_list.append(mfc_func(buffer[bufside_expr_dma],
                                                      ae + block_off, get_size,
                                                      tag_expr, 0, 0))
                    else: # unalign
                        mod = memop.buffer_var.mod_var
                        len_var = memop.buffer_var.len_var

                        double_buffer_first_get.append(emit_unaligned_mfc_mod(b, mod[0], len_var[0],
                                                                              align_size, mfc_ops,
                                                                              buffer[0],
                                                                              ea_type,
                                                                              pin0(ae,block_off_first),
                                                                              current_size,
                                                                              loop_node.nest_level*2))

                        if not put:
                            double_buffer_first_get.append(emit_unaligned_mfc_dma(b, mod[0], len_var[0],
                                                                                  align_size, mfc_func,
                                                                                  buffer[0],
                                                                                  ea_type,
                                                                                  pin0(ae,block_off_first),
                                                                                  current_size,
                                                                                  loop_node.nest_level*2))

                        elif is_partial_store:
                            double_buffer_first_get.append(emit_unaligned_mfc_dma(b, mod[0], len_var[0],
                                                                                  align_size, mfc_ops.getf,
                                                                                  buffer[0],
                                                                                  ea_type,
                                                                                  pin0(ae,block_off_first),
                                                                                  current_size,
                                                                                  loop_node.nest_level*2))

                        double_buffer_dma_get.append(emit_unaligned_mfc_mod(b, mod[bufside_expr_get], len_var[bufside_expr_get],
                                                                            align_size, mfc_ops,
                                                                            buffer[bufside_expr_get],
                                                                            ea_type,
                                                                            pin0(ae,block_off_get), get_size,
                                                                            tag_expr_get))

                        if is_partial_store:
                            double_buffer_dma_get.append(emit_unaligned_mfc_dma(b, mod[bufside_expr_get], len_var[bufside_expr_get],
                                                                                align_size, mfc_ops.getf,
                                                                                buffer[bufside_expr_get],
                                                                                ea_type, ae + block_off_get, dma_size,
                                                                                tag_expr_get))


                        if put:
                            mfc_stmt_list.append(mfc_ops.put_unaligned(pin0(b.cast(b.puchar,loop_pointer), dma_off),
                                                                       pin0(pin0(ae, block_off_dma), dma_off),
                                                                       min0(dma_size,dma_off), tag_expr_dma, 0, 0))
                        else:
                            mfc_stmt_list.append(emit_unaligned_mfc_dma(b, mod[bufside_expr_dma], len_var[bufside_expr_dma],
                                                                        align_size, mfc_func,
                                                                        buffer[bufside_expr_dma],
                                                                        ea_type, ae + block_off_dma, dma_size,
                                                                        tag_expr_dma))



                else: # single buffer
                    if ignore_unalign:
                        mfc_stmt_list.append(mfc_func(buffer, ae + block_off_dma, get_size,
                                                      0, 0, 0))
                    else: # unalign
                        mod = memop.buffer_var.mod_var
                        len_var = memop.buffer_var.len_var

                        if is_partial_store:
                            dma_get_stmts.append(emit_unaligned_mfc_mod(b, mod, len_var,
                                                                            align_size, mfc_func,
                                                                            buffer,
                                                                            ea_type, ae + block_off_dma, dma_size,
                                                                            tag_expr))
                            dma_get_stmts.append(emit_unaligned_mfc_dma(b, mod, len_var,
                                                                        align_size, mfc_ops.getf,
                                                                        buffer,
                                                                        ea_type, ae + block_off_dma, dma_size,
                                                                        tag_expr))
                        else:
                            mfc_mod_stmt_list.append(emit_unaligned_mfc_mod(b, mod, len_var,
                                                                            align_size, mfc_func,
                                                                            buffer,
                                                                            ea_type, ae + block_off_dma, dma_size,
                                                                            tag_expr))

                        if put:
                            mfc_stmt_list.append(mfc_ops.put_unaligned(pin0(b.cast(b.puchar,loop_pointer), dma_off),
                                                                       pin0(pin0(ae, block_off_dma), dma_off),
                                                                       min0(dma_size,dma_off), tag_expr, 0, 0))
                        else:
                            mfc_stmt_list.append(emit_unaligned_mfc_dma(b, mod, len_var,
                                                                        align_size, mfc_func,
                                                                        buffer,
                                                                        ea_type, ae + block_off_dma, dma_size,
                                                                        tag_expr))

            if not buffer in adjust_emitted:
                pointer_type = b.pointer_to(load_type)
                adjust_emitted[buffer] = True
                (range_min, range_max) = memop.load_data_range()
                off_expr = -range_min
                if double_buffering:
                    if ignore_unalign:
                        adjust_buffer_stmt.append(b.assign(loop_pointer,
                                                           plus_if_not0(buffer[bufside],off_expr)))
                    else: # unalign
                        mod = memop.buffer_var.mod_var
                        buffer_addr = byte_offset_ptr_add(b, pointer_type, buffer[bufside], mod[bufside])
                        adjust_buffer_stmt.append(b.assign(loop_pointer,
                                                           plus_if_not0(buffer_addr, off_expr)))
                else: # single buffer
                    if ignore_unalign:
                        adjust_buffer_stmt.append(b.assign(loop_pointer,
                                                           plus_if_not0(buffer,off_expr)))
                    else: # unalign
                        mod = memop.buffer_var.mod_var
                        buffer_addr = byte_offset_ptr_add(b, pointer_type, buffer, mod)
                        adjust_buffer_stmt.append(b.assign(loop_pointer,
                                                           plus_if_not0(buffer_addr, off_expr)))



        for i in vector_load_ops:
            vector_dma_op(i)
        for i in vector_store_ops:
            vector_dma_op(i)

        if double_buffering:
            tag_expr = b.binary(Binary.LSHIFT, 1, b.paren(plus_if_not0(bufside,loop_node.nest_level*2)))
        else:
            tag_expr = 1
            bufside_expr = 1

        if (len(double_buffer_dma_get) + len(dma_get_stmts) + len(dma_put_stmts)) != 0:
            dma_get_stmts.append([mfc_ops.write_tag_mask(tag_expr),
                                  mfc_ops.read_tag_status_all()])

            block_loop = [double_buffer_first_get,
                          b.for_(block_init,
                             block_cond,
                             block_iter,
                             b.comp(block_body, mfc_mod_stmt_list, dma_get_stmts, 
                                    adjust_buffer_stmt, inner_loop, dma_put_stmts, block_foot)),
                      mfc_ops.write_tag_mask(3),
                      mfc_ops.read_tag_status_all()]

        block_loop = [first_iv_init, before_block_stmts, decls, block_loop]

        loop_stmt.replace(b.build_stmt(block_loop))
    else:
        cond = convert_cond(b, exit_info, all_loop_count)

        body = loop_stmt.body
#        if body.code == ctrump.STMT_COMPOUND:
#            body = body.items

        if all_loop_count:
            init = b.empty_expr()
        else:
            init = loop_stmt.init

        inner_loop = offload_loop(b, loop_node, init, cond, loop_stmt.iter, body,
                                  scalar_get_stmts, scalar_put_stmts)

        loop_stmt.replace(b.build_stmt([first_iv_init, inner_loop]))

        for i in ops:
            emit_env.all_scalar_iv += i.extract_iv(ptr_inc_var)

        # wow! very dirty
        class IVWrapper:
            def __init__(self, var):
                self.var = var
                self.iv_level = loop_node.nest_level
        emit_env.all_scalar_iv.append(IVWrapper(loop_counter))

    for i in memop_node.children:
        emit_loop_node(b, mem_size, i, emit_env, mfc_ops,
                       None, start_offset, top_loop_nest_level, mem_access_emitted, seq_map)

    for i in ops:
        replace_array_ref_expr(b, i, double_buffering, ignore_unalign)

    return loop_stmt

def decl_var_list(b, vars, declared):
    ret = []
    for i in vars:
        name = i.var.name
        if i.var.type.code != ctrump.TYPE_FUNC:
            if not name in declared:
                type = i.var.type
                ret.append(b.decl(type, name))
                declared[name] = True
    return ret

def get_loop_blocks_0(bb, exit, emitted, blocks):
    if bb != exit and not bb in emitted:
        emitted[bb] = True
        blocks.append(bb)

        for i in bb.succs:
            get_loop_blocks_0(i, exit, emitted, blocks)
    

def get_loop_blocks(loop_cfg_info):
    exit = loop_cfg_info.break_bb
    emitted = {}
    blocks = []

    get_loop_blocks_0(loop_cfg_info.cond_bb, exit, emitted, blocks)
    return blocks

class OffloadSpeTranslator(LoopTranslatorBase):
    def __init__(self):
        super(OffloadSpeTranslator,self).__init__()

    def get_name(self):
        return SELF_TRANSLATOR_NAME

    def get_global_option(self):
        return global_option

    def get_translate_option(self):
        return translate_option

    def translate(self, analyze_result, stmt, cfg, loop_info_node, global_options, translate_option, prog):
        translator_global_option = global_options.translators[SELF_TRANSLATOR_NAME]

        program_obj_name = translate_option['name_of_spe_program']
        parameter_var_name = translate_option['parameter_var_name']
        buf_size = translate_option['buf_size']
        align_128 = translate_option['get_align_128']
        ignore_small_size = False # translate_option['ignore_small_size']
        ignore_unaligned_data = False # translate_option['ignore_unaligned_data']
        double_buffering = translate_option['doublebuffering']

        align_size = 16
        if align_128:
            align_size = 128

        get_spe_num = 'ctrump_spe_num'
        get_spe_template = 'ctrump_runtime_spes[%s].spe_context' # translator_global_option['get_spe_expr']
        max_spe_num = translator_global_option['max_spe_num']
        address_mode = translator_global_option['address_mode']

        spe_runtime_name = SPE_LIBSPE2 # translator_global_option['spe_runtime_name']
        spe_runtime_mod = spe_runtime_table[spe_runtime_name]

        env_obj = stmt.env_obj
        b = Builder(env_obj)
        s = b.scope

        spe_runtime = spe_runtime_mod.create(b)

        li = loop_info_node.loop_node
        invariants_bmp = li.invariant_var
        invariants = bitmap_var_info(cfg.var_info, invariants_bmp)

        if address_mode == 64:
            ea_type = b.ullong
            abi = ctrump.ppc64_abi
        else:
            ea_type = b.uint
            abi = ctrump.ppc32_abi

        emit_env = EmitEnv(abi, ea_type, align_size, ignore_unaligned_data, double_buffering)

        spe_param_in_member_list = [(ea_type, 'sync_buffer_ea'),
                                    (b.int_,'start'),
                                    (b.int_,'loop_count'),
                                    (b.int_,'all_loop_count'),
                                    (b.int_,'spe_id'),
                                    (b.int_,'is_last_spe')]

        memory_operation = loop_tree_to_memop_tree(li)
        memory_operation.optimize()
        memop_tree = memory_operation.tree

        load_store = []

        invariants_and_incptrs = [] # (orignal_type, ea_type, var)

        for i in invariants:
            var = i.var
            if var.name in emit_env.variables:
                continue

            original_texpr = var.type
            pointer_texpr = ctrump.type_apply_unary_pointer_conversion(original_texpr)
            if pointer_texpr:
                texpr = ea_type
            else:
                texpr = original_texpr
            invariants_and_incptrs.append((original_texpr, texpr, var))
            emit_env.variables[var.name] = True

        (loop_cond_ind, loop_iv_reach, loop_iv_incr) = EI.get_loop_counter(li.exit_info)
        # fixme : very dirty 
        loop_init_stmt = b.b.stmt_expr(code=ctrump.STMT_EXPR, expr=stmt.init)

        loop_iv_is_zero = False

        if loop_iv_reach.code == ctrump.PDG_VALUE_EXPR:
            entry_val = ctrump.fold_const(loop_iv_reach.val)
            if (None != entry_val) and entry_val == 0:
                loop_iv_is_zero = True

        if not loop_iv_is_zero:
            name = li.exit_info.inductive.name
            if not name in emit_env.variables:
                emit_env.variables[name] = True
                invariants_and_incptrs.append((b.int_, b.int_, li.exit_info.inductive))

        gather_buffer_name(memory_operation, invariants_and_incptrs,
                           emit_env.variables, ea_type)

        for (orig_t, param_t, var) in invariants_and_incptrs:
            spe_param_in_member_list.append((param_t,var.name))

        spe_param_out_member_list = []

        for i in li.reductions:
            spe_param_out_member_list.append((i.var.type, i.var.name))

        have_spe_output = (len(spe_param_out_member_list) != 0)

        spe_param_decl = []

        if have_spe_output:
            spe_param_in_typespec = b.struct('spe_param_in', spe_param_in_member_list, attr_align=align_size)
            spe_param_out_typespec = b.struct('spe_param_out', spe_param_out_member_list, attr_align=align_size)
            spe_param_type_spec = b.union('spe_param', [(spe_param_in_typespec,'in'),
                                                        (spe_param_out_typespec,'out')], attr_align=align_size)

            param_struct_decl = [
                b.struct_decl(spe_param_in_typespec),
                b.struct_decl(spe_param_out_typespec),
                b.struct_decl(spe_param_type_spec)]
        else:
            spe_param_type_spec = b.struct('spe_param', spe_param_in_member_list, attr_align=align_size)
            param_struct_decl = b.struct_decl(spe_param_type_spec)
            
        param_typedef_decl = b.decl(spe_param_type_spec, 'spe_param_t', stor_class=ctrump.STOR_CLASS_TYPEDEF)
        param_type_size = b.calc_type_size(abi, spe_param_type_spec)*max_spe_num + align_size
        spe_param_array_type_spec = b.array_of(b.uchar, param_type_size)
        spe_param_ptr_type_spec = b.pointer_to(s.spe_param_t)
        spe_param_array_decl = b.decl(spe_param_array_type_spec, 'spe_param_buffer')
        param_mod_ea = b.decl(ea_type, 'param_ea_mod', init=b.band(b.cast(ea_type, s.spe_param_buffer) , (align_size-1)))

        spe_param_ptr_decl = b.decl(spe_param_ptr_type_spec, parameter_var_name)
        align_param_addr = b.assign(s[parameter_var_name] ,
                                    b.cast(b.pointer_to(s.spe_param_t), s.spe_param_buffer + b.sub(align_size , s.param_ea_mod)))

        sync_buffer_decl = b.decl(b.array_of(b.uchar, 256), 'sync_buffer')
        sync_buffer_ptr_decl = b.decl(b.pointer_to(b.uchar), 'sync_buffer_ptr')
        sync_buffer_ea_mod = b.decl(b.pointer_to(b.uchar), 'sync_buffer_ea_mod',
                                    init = b.cast(b.pointer_to(b.uchar),
                                                  b.band(b.cast(ea_type, s.sync_buffer), 127)))

        sync_buffer_ptr_align = b.assign(s.sync_buffer_ptr,
                                         b.cast(b.pointer_to(b.uchar), s.sync_buffer + b.sub(128, s.sync_buffer_ea_mod)))

        # *(unsigned int)sync_buffer_ptr = 0
        sync_buffer_init = b.assign(b.ptr_ref(b.cast(b.pointer_to(b.uint),
                                                     s.sync_buffer_ptr)),
                                    0)

        spe_param_decl = [
            param_struct_decl,
            param_typedef_decl,
            spe_param_ptr_decl,
            spe_param_array_decl,
            param_mod_ea,
            align_param_addr,
            sync_buffer_decl,
            sync_buffer_ea_mod,
            sync_buffer_ptr_decl,
            sync_buffer_ptr_align,
            sync_buffer_init
            ]

        spe_program_typespec = spe_runtime.program_typespec()
        spe_obj_typespec = spe_runtime.speobj_typespec()
        emit_spe_program_load = spe_runtime.get_program_load_func()
        emit_run = spe_runtime.get_run_func()
        emit_wait = spe_runtime.get_wait_func()
        emit_spe_end = spe_runtime.get_spe_end_func()

        program_decl = b.decl(spe_program_typespec, program_obj_name, stor_class=ctrump.STOR_CLASS_EXTERN)
        program_obj = s[program_obj_name]

        get_spe = get_spe_template%'spe_id'

        exit_info = li.exit_info
        loop_count_incr = exit_info.incr
        bound_expr = b.expr(exit_info.bound)

        if loop_count_incr != 1:
            bound_expr = bound_expr+(loop_count_incr-1)
            all_loop_count_expr = bound_expr/loop_count_incr
            all_loop_count_decl = b.decl(b.int_, 'all_loop_count', init=all_loop_count_expr)
            all_loop_count = s.all_loop_count
        else:
            all_loop_count_expr = bound_expr
            all_loop_count_decl = None
            all_loop_count = bound_expr

        align_padding = 32
        if align_128:
            align_padding = 256

        seq_map = {}
        sequential_test(memop_tree, seq_map)
        sequential_test_0(memory_operation.invariants, -1, seq_map)

        memsize = calc_memop_size(memop_tree, emit_env, buf_size)

        for i in memory_operation.invariants:
            calc_memop_size_1(i, memsize, emit_env)

        if double_buffering:
            memsize.secondary_offset = buf_size/2

        spe_dispatch_unit = memsize.spe_dispatch_unit
        block_elem_count = memsize.block_elem_count

        if block_elem_count <= 0:
            raise Exception("too large data size")

        spe_num_decls = []
        spe_num_decls.append(b.decl(b.int_, 'spe_num', init=get_spe_num))
        spe_num_var = s.spe_num
        params_var = s[parameter_var_name]

        init_param_stmts = []
        speid_decl = b.decl(b.int_, 'spe_id')

        pvs = params_var[s.spe_id]

        for (orig_t,param_t,var) in invariants_and_incptrs:
            name = var.name
            expr = b.varref(var)

            if orig_t != param_t:
                expr = b.cast(param_t, expr)

            init_param_stmts.append(b.assign(spe_in_param_member(have_spe_output, pvs, name),
                                             expr))
            

        spe_num_decls.append(b.decl(b.int_, 'all_units', init = gen_ceil_div(all_loop_count,spe_dispatch_unit)))

        if not ignore_small_size:
            spe_num_decls.append(b.if_(s.all_units < s.spe_num,
                                       b.comp(b.assign(s.spe_num , s.all_units))))

        unit_num_decl = b.decl(b.int_, 'per_spe_units', init = s.all_units/s.spe_num)
        per_spe_loop_count = mul_if_not1(s.per_spe_units, spe_dispatch_unit)
        per_spe_loop_count_decl = b.decl(b.int_, 'per_spe_loop_count', init=per_spe_loop_count)

        spe_param_member_list = [(ea_type, 'sync_buffer_ea'),
                                 (b.int_,'start'),
                                 (b.int_,'loop_count')]

        init_param_stmts.append(
            [b.assign(spe_in_param_member(have_spe_output, pvs, 'start'),
                      s['spe_id'] * s.per_spe_loop_count),
             b.assign(spe_in_param_member(have_spe_output, pvs, 'loop_count'),s.per_spe_loop_count),
             b.assign(spe_in_param_member(have_spe_output, pvs, 'is_last_spe'),b.paren(s.spe_id == (s.spe_num-1))),
             b.assign(spe_in_param_member(have_spe_output, pvs, 'spe_id'),s.spe_id),
             b.assign(spe_in_param_member(have_spe_output, pvs, 'all_loop_count'),all_loop_count),
             b.assign(spe_in_param_member(have_spe_output, pvs, 'sync_buffer_ea'),b.cast(ea_type,s.sync_buffer_ptr))])

        if have_spe_output:
            gather_reduction = [b.newline()]
            gather_loop_body = []
            for i in li.reductions:
                var = i.var

                if i.op == ctrump.REDUCTIVE_ADD or i.op == ctrump.REDUCTIVE_FADD:
                    op = ctrump.EXPR_BIN_ADD
                elif i.op == ctrump.REDUCTIVE_SUB or i.op == ctrump.REDUCTIVE_FSUB:
                    op = ctrump.EXPR_BIN_ADD
                elif i.op == ctrump.REDUCTIVE_MUL or i.op == ctrump.REDUCTIVE_FMUL:
                    op = ctrump.EXPR_BIN_MUL
                elif i.op == ctrump.REDUCTIVE_BOR:
                    op = ctrump.EXPR_BIN_BOR
                elif i.op == ctrump.REDUCTIVE_BAND:
                    op = ctrump.EXPR_BIN_BAND
                elif i.op == ctrump.REDUCTIVE_BXOR:
                    op = ctrump.EXPR_BIN_BXOR
                elif i.op == ctrump.REDUCTIVE_LAND:
                    op = ctrump.EXPR_BIN_LAND
                elif i.op == ctrump.REDUCTIVE_LXOR:
                    op = ctrump.EXPR_BIN_LXOR
                else:
                    raise 'invalid reduction'

                gather_loop_body.append(b.assign(b.varref(var),
                                                 b.binary(op, b.varref(var),
                                                          params_var[s.spe_id].member('out').member(var.name))))

            gather_loop = b.for_ (b.assign(s.spe_id , 0),
                                  s.spe_id < s.spe_num,
                                  b.postinc(s.spe_id),
                                  b.comp(gather_loop_body))

            gather_reduction.append(gather_loop)
            gather_reduction.append(b.newline())
        else:
            gather_reduction = []

        ppe_tree = b.comp(
            loop_init_stmt,
            spe_param_decl,
            b.newline(),
            all_loop_count_decl,
            spe_num_decls,
            b.newline(),
            unit_num_decl,
            per_spe_loop_count_decl,
            speid_decl,
            program_decl,
            b.newline(),
            b.for_ (b.assign(s.spe_id , 0),
                    s.spe_id < s.spe_num,
                    b.postinc(s.spe_id),
                    b.comp(b.decl(spe_obj_typespec, 'cur_spe'),  # spe_obj_t cur_spe;
                           b.assign(s.cur_spe , get_spe),        # cur_spe = spe_id;
                           emit_spe_program_load(s.cur_spe, program_obj),
                           b.newline(),
                           init_param_stmts,
                           b.newline(),
                           emit_run(s.cur_spe, b.addr(params_var[s.spe_id]))
                           )
                    ),

            b.newline(),
            emit_wait(get_spe_template%'spe_num-1'),
            gather_reduction,
            )

        # create SPE program

        s = b.clear_scope()

        (buffer_decl_global, buffer_decl_local) = emit_buffer_declaration(b, memsize, 'spe_buffer', buf_size, memop_tree,
                                                                          memory_operation.invariants,
                                                                          emit_env)

        use_vars = bitmap_var_info(cfg.var_info, li.use)
        use_kill_decls = decl_var_list(b, use_vars, emit_env.variables)

        modify_vars = bitmap_var_info(cfg.var_info, li.modify)
        use_kill_decls.append(decl_var_list(b, modify_vars, emit_env.variables))

        param_typedef_decl = b.decl(spe_param_type_spec, 'spe_param_t', stor_class=STOR_CLASS_TYPEDEF)
        param_decl = b.decl('spe_param_t', parameter_var_name, stor_class=STOR_CLASS_STATIC, align=128)

        func_args = b.func_argdecl([(b.ullong, 'spe'),
                                    (b.ullong, 'argp'),
                                    (b.ullong, 'envp')])
        mfc_get = b.func('mfc_get')
        mfc_put = b.func('mfc_put')
        mfc_getf = b.func('mfc_getf')
        mfc_putf = b.func('mfc_putf')
        ctrump_put_unaligned_func = b.func('ctrump_put_unaligned')

        def ctrump_put_unaligned(ls,ea,size,tag,tid,rid):
            if isinstance(size,int) and ((size == 1) or (size == 2) or (size == 4) or (size == 8)):
                return mfc_put(ls,ea,size,tag,tid,rid)

            return ctrump_put_unaligned_func(ls,ea,size,tag,tid,rid)

        mfc_write_tag_mask = b.func('mfc_write_tag_mask')
        mfc_read_tag_status_all = b.func('mfc_read_tag_status_all')

        spe_param = s[parameter_var_name]
        init_param_stmts = []

        for (orig_t,param_t,var) in invariants_and_incptrs:
            name = var.name
            expr = spe_in_param_member(have_spe_output, spe_param, name)
            pointer_texpr = ctrump.type_apply_unary_pointer_conversion(orig_t)
            if pointer_texpr:
                texpr = ea_type
                name = 'ea_' + str(name)
            else:
                texpr = orig_t

            init_param_stmts.append(b.decl(texpr, name, init=expr))

        decl_reduction = []

        calc_loop_count = []
        calc_loop_count.append(
            [b.decl(b.int_, 'per_spe_loop_count', init = spe_in_param_member(have_spe_output, spe_param, 'loop_count')),
             b.decl(b.int_, 'spe_id', init = spe_in_param_member(have_spe_output, spe_param, 'spe_id')),
             b.decl(b.int_, 'is_last_spe', init = spe_in_param_member(have_spe_output, spe_param, 'is_last_spe')),
             b.decl(ea_type, 'sync_buffer_ea', init = spe_in_param_member(have_spe_output, spe_param, 'sync_buffer_ea')),
             b.newline(),
             b.if_(s.is_last_spe,
                   b.comp(b.assign(s.per_spe_loop_count ,
                                   (spe_in_param_member(have_spe_output, spe_param, 'all_loop_count')-
                                    (s.per_spe_loop_count*s.spe_id))))),
             b.decl(b.int_, 'start_offset',init = spe_in_param_member(have_spe_output, spe_param, 'start'))
             ])

        for i in li.reductions:
            name = i.var.name

            if name in emit_env.variables:
                decl_reduction.append(b.assign(s[name], 0))
            else:
                declred[name] = True
                decl_reduction.append(b.decl(i.var.type, i.var.name, init = 0))

        unaligned_decl = []

        mem_access_emitted = {}

        class MfcOps:
            def __init__(self):
                self.write_tag_mask = mfc_write_tag_mask
                self.read_tag_status_all = mfc_read_tag_status_all
                self.get = mfc_get
                self.put = mfc_put
                self.putf = mfc_putf
                self.getf = mfc_getf
                self.put_unaligned = ctrump_put_unaligned

        mfc_ops = MfcOps()

        invariant_get_stmts = []
        invariant_put_stmts = []
        invariant_adjust_buffer_stmts = []

        for i in memory_operation.invariants:
            emit_memory_access(b, i,
                               align_size, mfc_ops, emit_env,
                               s.start_offset, memop_tree.loop_node.nest_level, mem_access_emitted)

            invariant_get_stmts.append(i.scalar_dma_get_stmts)
            invariant_put_stmts.append(i.scalar_dma_put_stmts)

            pointer_type = b.pointer_to(i.load_data_type())
            buffer = i.buffer_var.buffer
            mod = i.buffer_var.mod_var

            if double_buffering:
                buffer_addr = byte_offset_ptr_add(b, pointer_type, buffer[0], mod[0])
            else:
                buffer_addr = byte_offset_ptr_add(b, pointer_type, buffer, mod)

            invariant_adjust_buffer_stmts.append(b.assign(i.loop_pointer, buffer_addr))

        for i in memory_operation.invariants:
            replace_array_ref_expr(b, i, double_buffering, ignore_unaligned_data)

        stmts = emit_loop_node(b, memsize, memop_tree, emit_env,
                               mfc_ops, s.per_spe_loop_count, s.start_offset,
                               memop_tree.loop_node.nest_level, mem_access_emitted, seq_map)

        typedef_invariants = {}

        for i in invariants:
            var = i.var
            texpr = var.type
            append_typedefs(texpr, typedef_invariants)

        loop_blocks = get_loop_blocks(loop_info_node.loop_node.cfg_info)

        iv_replaced = {}

        top_loop_nest_level = memop_tree.loop_node.nest_level
        block_size = memsize.block_elem_count

        for bb in loop_blocks:
            for r in bb.load_store.stores:
                if (not r.var_ref in iv_replaced):
                    iv_replaced[r.var_ref] = True

            for r in bb.load_store.refs:
                for x in emit_env.all_block_iv:

                    if x.iv_level == top_loop_nest_level:
                        replace_expr = b.paren(b.varref(x.var)+s['block_%s'%x.var.name]*block_size+s.start_offset)
                    else:
                        replace_expr = b.paren(b.varref(x.var)+s['block_%s'%x.var.name]*block_size)

                    if (not r.ref_expr in iv_replaced and r.ref_expr.var.name == x.var.name):
                        iv_replaced[r.ref_expr] = True
                        r.ref_expr.replace(b.build_expr(replace_expr))

                for x in emit_env.all_scalar_iv:
                    if x.iv_level == top_loop_nest_level:
                        replace_expr = b.paren(b.varref(x.var)+s.start_offset)
                    else:
                        replace_expr = b.varref(x.var)

                    if (not r.ref_expr in iv_replaced and r.ref_expr.var.name == x.var.name):
                        iv_replaced[r.ref_expr] = True
                        r.ref_expr.replace(b.build_expr(replace_expr))


        typedef_invariants_stmt = []
        struct_list = []
        for i in typedef_invariants:
            c = i.code
            if c == ctrump.TYPE_TYPEDEF_NAME:
                ctrump.spe.convert_type_ppe_to_spe(b, i.defined_to,
                                                   emit_env.structs,
                                                   emit_env.struct_pending,
                                                   emit_env.struct_list, abi)
                struct_list.append(type)

        pendings = emit_env.struct_pending
        while len(pendings) > 0:
            emit_env.struct_pending = []
            for i in pendings:
                ctrump.spe.convert_type_ppe_to_spe(b, i, emit_env.structs, emit_env.struct_pending, emit_env.struct_list, abi)
            
            pendings = emit_env.struct_pending

        emit_env.struct_list.reverse()
        for tp in emit_env.struct_list:
            typedef_invariants_stmt.append(b.struct_decl(tp))

        if have_spe_output:
            put_reduction = [b.newline()]

            for i in li.reductions:
                name = i.var.name
                put_reduction.append(b.assign(spe_param.member('out').member(name),
                                              s[name]))

            put_reduction.append(mfc_put(b.addr(spe_param), s.argp, b.sizeof(s[parameter_var_name]), 0, 0, 0))

            put_reduction.append(b.newline())
        else:
            put_reduction = []

        last_wait = [mfc_write_tag_mask(b.bcmpl(b.literal(0))),
                     mfc_read_tag_status_all()]

        main_body = [
            buffer_decl_local,
            use_kill_decls,
            unaligned_decl,
            decl_reduction,
            b.newline(),
            mfc_get(b.addr(spe_param), s.argp, b.sizeof(s[parameter_var_name]), 0, 0, 0),
            mfc_write_tag_mask(1),
            mfc_read_tag_status_all(),
            b.newline(),
            init_param_stmts,
            b.newline(),
            calc_loop_count,
            invariant_get_stmts,
            invariant_adjust_buffer_stmts,
            b.newline(),
            stmts,
            invariant_put_stmts,
            put_reduction,
            last_wait,
            emit_spe_end(have_spe_output, s.spe_id, s.is_last_spe, s.sync_buffer_ea)
            ]
        main = b.func_def(b.int_,'main',func_args,main_body)

        includes = [
            b.include("spu_mfcio.h"),
            b.include("spu_intrinsics.h"),
            b.include("ctrump.h"),
            spe_runtime.emit_include()
            ]

        extdefs = [
            includes,
            b.newline(),
            typedef_invariants_stmt,
            b.newline(),
            param_struct_decl,
            param_typedef_decl, 
            b.newline(),
            param_decl,
            buffer_decl_global,
            b.newline(),
            main
            ]

        spe_prog = b.translation_unit(extdefs, prog.filename)

        stmt.replace(b.build_stmt(ppe_tree))

        new_prog = b.translation_unit([b.include('ctrump/runtime/ctrump-libspe2.h'),
                                       b.newline(),
                                       prog.decls], prog.filename)

        return [new_prog, spe_prog]

    def is_enabled(self, analyze_results, stmt, cfg, loop_node, errors, warnings, hints):
        is_for_stmt = (stmt.code == ctrump.STMT_FOR)
        if not is_for_stmt:
            (stmt_loc_path, stmt_loc_line) = ctrump.get_stmt_loc(stmt)
            errors.append(OptimizationError([(stmt_loc_path, stmt_loc_line)],
                                            "ループがforループではありません."))

        if loop_node.dep_vec_dir == 0:
            pass #ok
        else:
            (stmt_loc_path, stmt_loc_line) = ctrump.get_stmt_loc(stmt)

            errors.append(OptimizationError([(stmt_loc_path, stmt_loc_line)],
                                            'ループ間に依存があります'))

            if loop_node.dep_vec_dir == loop_node.ANTI_DEP:
                hints.append(OptimizationError([(stmt_loc_path, stmt_loc_line)],
                                               '依存は逆依存(anti-dependency)です。出力バッファと入力バッファを分けると並列化できます。'))

            return False

        return (is_for_stmt and
                (loop_node.error_bits == 0))


def init_optimizer(engine):
    loop_optimizer = engine.get_loop_optimizer()

    loop_optimizer.append_translator(OffloadSpeTranslator(),
                                     [LoopParallelAnalyzer])

---