bb_edge_profile.cpp

Go to the documentation of this file.

/*
        Copyright (C) 1997 CFU Corporation

        File: bb_edge_profile.cpp
        Author: Chao-yinig Fu
        Date: Aug. 24 1998

        ^..^
        (00)

         $__$
        <~00~>
         (oo)
          ||

        ```````
        C ^|^ D
         \ O /
*/

#include "bb_edge_profile.h"
#include <stdio.h>
#include "util.h"
#include "cfg.h"
#include "node_table.h"
#include "edge_table.h"
#include "predicate.h"
#include <legoUtil.H>
#include "lego_util.h"
#include "instrument.h"

//#define BEDEBUG
#ifdef BEDEBUG
#define BELEVEL 1
#define BEdb(my_level,format,args...) emit_message2(BELEVEL,my_level,format,##args)
#else
#define BEdb(my_level,format,args...)
#endif // BEDEBUG

void BB_Edge_Profile::doit(legoModule *module_ptr,int option)
{
        //
        // Step 1. Initialize the true predicate, so that we can use it later
        //         Initialize _my_instrument for using later
        //
        Predicate::init_true_predicate_oprd();
        _my_instrument.initialize_parameters();


        FILE *bb_table_fp=NULL;
        FILE *edge_table_fp=NULL;
        int bb_start_index;
        int edge_start_index;

        int proc_count=module_ptr->GetCount();
        for(int i=0;i<proc_count;i++)
        {
                legoProc *proc_ptr;
                legoRegion *region_ptr;
                proc_ptr=(legoProc *)module_ptr->GetItem(i);
                assert(proc_ptr->GetRegionType()==RT_PROC);

                //
                // Step 1. Initialize the operand for instrumentation
                //
                _my_instrument.initialize_temp_registers(proc_ptr);

                //
                // Step 2. Rename _main to _MaiN, because we will create
                //      our own version of _main
                //
                if(strcmp(proc_ptr->GetProcName(),"_main")==0)
                {
                        _my_instrument.rename_main(module_ptr,proc_ptr);
                }

                //
                // Step 3. Build CFG
                //
                CFG *cfg=new CFG();
                cfg->build(proc_ptr);
                //cfg->print(stderr);

                //
                // Step 4. Build node_table
                //
                _bb_node_table=new Node_Table();

                if(i==0)
                {
                        //_bb_node_table->open_file_with_value("BBiD_PT");
                        _bb_node_table->open_file("BBiD_PT");
                        bb_table_fp=_bb_node_table->node_table_fp();
                }
                else
                {
                        _bb_node_table->set_node_table_fp(bb_table_fp);
                        _bb_node_table->set_start_index(bb_start_index);
                }

                _bb_node_table->build_from_proc(proc_ptr);
                //_bb_node_table->print_with_value2(_bb_node_table->node_table_fp());
                _bb_node_table->print(_bb_node_table->node_table_fp());
                //_bb_node_table->print_with_value2(stderr);
                bb_start_index=_bb_node_table->start_index();

                // 
                // Step 5. Build edge_table
                //
                _edge_table=new Edge_Table();

                if(i==0)
                {
                        _edge_table->open_new_or_old_file("eDGe_PT");
                        edge_table_fp=_edge_table->table_fp();
                }
                else
                {
                        _edge_table->set_table_fp(edge_table_fp);
                        _edge_table->set_start_index(edge_start_index);
                }

                _edge_table->build(cfg);
                _edge_table->profile_all_edges();
                _edge_table->print_to_file(_edge_table->table_fp());
                //_edge_table->print_to_file(stderr);
                edge_start_index=_edge_table->start_index();
                assert(edge_start_index>=0);

                //
                // Step 6. Reset bbid_start & bbid_end
                //
                reset_bbid_start();
                reset_bbid_end();

                //
                // Step 7. Instrument
                //
                instrument(proc_ptr);

                //
                // Step 8. check_max_op_id
                //
                check_max_op_id(proc_ptr);

                //
                // Step 9. Clear
                //
                delete cfg;
                delete _edge_table;
                delete _bb_node_table;
        }

        if(proc_count>0)
        {
                fclose(bb_table_fp);
                fclose(edge_table_fp);

                open_main_file(bb_start_index,edge_start_index);
                open_header_file();
                close_main_file();
                close_header_file();
        }
}

void BB_Edge_Profile::lego_write(legoModule *module_ptr,char *input_filename)
{
        char *output_filename=new char[strlen(input_filename)+9];
        strcpy(output_filename,input_filename);

        int i=strlen(input_filename)-3;

        output_filename[i+0]='_';
        output_filename[i+1]='B';
        output_filename[i+2]='B';
        output_filename[i+3]='_';
        output_filename[i+4]='e';
        output_filename[i+5]='D';
        output_filename[i+6]='G';
        output_filename[i+7]='e';
        output_filename[i+8]='.';
        output_filename[i+9]='e';
        output_filename[i+10]='l';
        output_filename[i+11]='\0';

        LegoWrite(module_ptr,output_filename);
}

void BB_Edge_Profile::instrument(legoProc *proc_ptr)
{
        recursive_instrument(proc_ptr,proc_ptr);
}

//
// This function will recursively call until reach the basic block region
// Inside the basic block, we will save int_p1, insert pbrr, insert call,
// and restore int_p1.
//
void BB_Edge_Profile::recursive_instrument(legoProc *proc_ptr,legoRegion *region_ptr)
{
        int sub_region_count;
        legoRegion *sub_region_ptr;

        regionTypes region_type=region_ptr->GetRegionType();

        switch(region_type)
        {
                case RT_PROC:
                        //fprintf(stderr,"RT_PROC\n");
                case RT_LOOP:
                        //fprintf(stderr,"RT_LOOP\n");
                case RT_LOOPBODY:
                        //fprintf(stderr,"RT_LOOPBODY\n");
                case RT_TRACE:
                        //fprintf(stderr,"RT_TRACE\n");
                case RT_TREE:
                        //fprintf(stderr,"RT_TREE\n");

                        sub_region_count=region_ptr->GetCount();
                        for(int i=0;i<sub_region_count;i++)
                        {
                                sub_region_ptr=(legoRegion *)region_ptr->GetItem
(i);
                                recursive_instrument(proc_ptr,sub_region_ptr);
                        }
                        break;
                case RT_SB:
                case RT_HB:
                case RT_BB:
                        insert_probe(proc_ptr,region_ptr);
                        break;

                default:
                        fprintf(stderr,"ERROR region_type\n");
                        assert(0);
                        break;
        }
}

void BB_Edge_Profile::insert_probe(legoProc *proc_ptr,legoRegion *region_ptr)
{

        //
        // Step 1. Insert bbid start probe
        //
        int region_id=region_ptr->GetRegionId();
        int mapping=_bb_node_table->find(region_id);
        opList *entry_op_list=region_ptr->GetEntryOpsPtr();
        legoOp *from_op_ptr=entry_op_list->GetOpPtr();
        int s_time=from_op_ptr->GetSchedTime();

        from_op_ptr=_my_instrument.append_save_and_set_1_param_code(mapping,proc_ptr,region_ptr,Predicate::true_predicate_oprd(),from_op_ptr,s_time);

        from_op_ptr=_my_instrument.append_pbrr_code(BB_EDGE_PROFILE_START_PROBE_NAME,proc_ptr,region_ptr,Predicate::true_predicate_oprd(),from_op_ptr,s_time);

        from_op_ptr=_my_instrument.append_brl_code(proc_ptr,region_ptr,Predicate::true_predicate_oprd(),from_op_ptr,1,s_time);

        from_op_ptr=_my_instrument.append_restore_1_param_code(proc_ptr,region_ptr,Predicate::true_predicate_oprd(),from_op_ptr,s_time);

        //
        // Step 2. Instrument exit op
        //
        for(opList *exit_op_list=region_ptr->GetExitOpsPtr();exit_op_list!=NULL;exit_op_list=exit_op_list->GetNextListPtr())
        {
                legoOp *exit_op=exit_op_list->GetOpPtr();
                if(exit_op!=NULL)
                {
                        BEdb(3,"exit_op %d %s",exit_op->GetOpId(),ParseMap(exit_op->GetOpcode()));
                        instrument_exit_op(proc_ptr,region_ptr,exit_op);
                        //getchar();
                }
        }
}


//
// If region_id doesn't have end probe, return 0
// else return 1
//
int BB_Edge_Profile::bbid_end_has_probe(int region_id)
{
        for(int i=0;i<_bbid_end_index;i++)
        {
                if(_bbid_end[i]==region_id)
                        return 1;
        }
        return 0;
}

void BB_Edge_Profile::bbid_end_insert(int region_id)
{
        _bbid_end[_bbid_end_index]=region_id;
        _bbid_end_index++;
        assert(_bbid_end_index<MAX_BB_ENTRY);
}

void BB_Edge_Profile::reset_bbid_start()
{
        for(int i=0;i<MAX_BB_ENTRY;i++)
        {
                _bbid_start[i]=0;
        }

        _bbid_start_index=0;
}

void BB_Edge_Profile::reset_bbid_end()
{
        for(int i=0;i<MAX_BB_ENTRY;i++)
        {
                _bbid_end[i]=0;
        }

        _bbid_end_index=0;
}

//
// If region_id doesn't have start probe, return 0
// else return 1
//
int BB_Edge_Profile::bbid_start_has_probe(int region_id)
{
        for(int i=0;i<_bbid_start_index;i++)
        {
                if(_bbid_start[i]==region_id)
                        return 1;
        }
        return 0;
}

void BB_Edge_Profile::bbid_start_insert(int region_id)
{
        _bbid_start[_bbid_start_index]=region_id;
        _bbid_start_index++;
        assert(_bbid_start_index<MAX_BB_ENTRY);
}


//
// Check the exit_op
// and decide to insert probe or nto
//
void BB_Edge_Profile::instrument_exit_op(legoProc *proc_ptr,legoRegion *region_ptr,legoOp *exit_op)
{
        int exit_opcode=exit_op->GetOpcode();
        int s_time=exit_op->GetSchedTime();
        BEdb(1,"proc %s region_id %d",proc_ptr->GetProcName(),region_ptr->GetRegionId());
        BEdb(1,"exit_op %d %s",exit_op->GetOpId(),ParseMap(exit_opcode));

        //
        // Step 0. check if exit_op's predicate is true predicate
        //
        if(exit_opcode!=DUMMY_BR)
        {
                legoOprd *exit_op_pred=exit_op->GetPredOprdPtr();
                assert(exit_op_pred!=NULL);
                assert(exit_op_pred->GetNextOprdPtr()==NULL);
                assert(exit_op_pred->GetOprdType()==OT_LITERAL_P && exit_op_pred->GetBooleanVal()==1);
        }



        opList *out_list=exit_op->GetOutListPtr();
        assert(out_list!=NULL);

        if(exit_opcode==DUMMY_BR || exit_opcode==BRU)
        {
                //
                // Case 1. One path only
                //
                // If there is only one destination, just insert 
                // _MY_1_PRoBe before exit_op
                // _MY_1_PRoBe has the parameter of the edge mapping id
                //
                if(out_list->GetNextListPtr()==NULL)
                {
                        legoOp *to_op=out_list->GetOpPtr();
                        int to_opid=to_op->GetOpId();
                        BEdb(2,"to %d",to_opid);

                        edgeList *edge_list=find_edgeList_from_op_to_op(region_ptr,exit_op,to_op);
                        assert(edge_list!=NULL);
                        BEdb(3,"edge_id %d",edge_list->GetEdgeId());

                        Edge *e=_edge_table->find_edge(edge_list->GetEdgeId());
                        BEdb(2,"%d\t%d\t%d\t%d\n",e->counter_index(),e->profile(),e->edge_id(),e->weight());

                        int path_mapping=e->counter_index();

                        //
                        // FIX
                        //insert_1_probe(proc_ptr,region_ptr,Predicate::true_predicate_oprd(),path_mapping,exit_op,"_MY_1_PRoBe"); 

                        _my_instrument.prepend_save_and_set_1_param_code(path_mapping,proc_ptr,region_ptr,Predicate::true_predicate_oprd(),exit_op,s_time);
                        _my_instrument.prepend_pbrr_code(BB_EDGE_PROFILE_1_PROBE_NAME,proc_ptr,region_ptr,Predicate::true_predicate_oprd(),exit_op,s_time);
                        _my_instrument.prepend_brl_code(proc_ptr,region_ptr,Predicate::true_predicate_oprd(),exit_op,1,s_time);
                        _my_instrument.prepend_restore_1_param_code(proc_ptr,region_ptr,Predicate::true_predicate_oprd(),exit_op,s_time);

                } 
                //
                // Case 2. Multiple Paths (switch statement)
                //
                // If there are more than one destination (switch statement),
                // insert _MY_BBiD_eND_PRoBe
                // _MY_BBiD_eND_PRoBe has the parameter of the (bbid mapping+100000)
                //
                else
                {
                        int exit_opid=exit_op->GetOpId();
                        fprintf(stderr,"ERROR!!! proc %s region %d:\n",proc_ptr->GetProcName(),region_ptr->GetRegionId());
                        fprintf(stderr,"exit_op %d %s has more than one out edges (switch statement)\n",exit_opid,ParseMap(exit_opcode));

                        int exit_op_region_id=region_ptr->GetRegionId();
                        if(bbid_end_has_probe(exit_op_region_id)==0)
                        {
                                fprintf(stderr,"bb %d doesn't have end probe. Insert it.\n",exit_op_region_id);
                                //
                                // Set the bit
                                //
                                bbid_end_insert(exit_op_region_id);

                                //
                                // insert probe before exit_op
                                //
                                int bbid_mapping=_bb_node_table->find(exit_op_region_id);

                                fprintf(stderr,"bbid_mapping=%d\n",bbid_mapping);
                                //
                                // For end probe, mapping=bbid_mapping+100000
                                //
                                int end_mapping=bbid_mapping+100000;

                                //
                                // FIX
                                //insert_1_probe(proc_ptr,region_ptr,Predicate::true_predicate_oprd(),end_mapping,exit_op,"_MY_BBiD_eND_PRoBe");

                                _my_instrument.prepend_save_and_set_1_param_code(end_mapping,proc_ptr,region_ptr,Predicate::true_predicate_oprd(),exit_op,s_time);
                                _my_instrument.prepend_pbrr_code(BB_EDGE_PROFILE_eND_PROBE_NAME,proc_ptr,region_ptr,Predicate::true_predicate_oprd(),exit_op,s_time);
                                _my_instrument.prepend_brl_code(proc_ptr,region_ptr,Predicate::true_predicate_oprd(),exit_op,1,s_time);
                                _my_instrument.prepend_restore_1_param_code(proc_ptr,region_ptr,Predicate::true_predicate_oprd(),exit_op,s_time);

                        }
                        else
                        {
                                fprintf(stderr,"bb %d has end probe already.  Don't need to insert it.\n",exit_op_region_id);
                        }


                        /*
                        //
                        // Just for knowing where those targets are
                        //
                        opList *my_out_list=exit_op->GetOutListPtr();
                        for(;my_out_list!=NULL;my_out_list=my_out_list->GetNextListPtr())
                        {
                                legoOp *my_to_op=my_out_list->GetOpPtr();
                                int my_to_opid=my_to_op->GetOpId();
                                legoRegion *my_region_ptr=find_lego_block_with_op_id(proc_ptr,my_to_opid);
                                int my_region_id=my_region_ptr->GetRegionId();

                                edgeList *my_edge_list=find_edgeList_from_op_to_op(region_ptr,exit_op,my_to_op);
                                int my_edge_id=my_edge_list->GetEdgeId();

                                Edge *my_e=_edge_table->find_edge(my_edge_id);
                                int my_mapping=my_e->counter_index();

                                fprintf(stderr,"goto CB_LAB %d OpId %d (edge %d, mapping %d)\n",my_region_id,my_to_opid,my_edge_id,my_mapping);

                        }
                        */
                }
        }
        //
        // Case 3. Two Paths (Fall through and Taken paths)
        //
        else if(exit_opcode==BRCT)
        {
                int to_opid1=-1,to_opid2=-1;
                Edge *e1=NULL,*e2=NULL;

                //
                // Step 1. First Edge Processing
                //
                legoOp *to_op1=out_list->GetOpPtr();
                to_opid1=to_op1->GetOpId();
                BEdb(2,"1) to %d",to_opid1);

                edgeList *edge_list1=find_edgeList_from_op_to_op(region_ptr,exit_op,to_op1);

                if(edge_list1!=NULL)
                {
                        BEdb(3,"1) edge_id %d",edge_list1->GetEdgeId());

                        e1=_edge_table->find_edge(edge_list1->GetEdgeId());
                        BEdb(2,"1) %d\t%d\t%d\t%d\n",e1->counter_index(),e1->profile(),e1->edge_id(),e1->weight());
                }


                //
                // Step 2. Second Edge Processing
                //
                out_list=out_list->GetNextListPtr();
                assert(out_list!=NULL);
                assert(out_list->GetNextListPtr()==NULL);

                legoOp *to_op2=out_list->GetOpPtr();
                to_opid2=to_op2->GetOpId();
                BEdb(2,"2) to %d",to_opid2);

                edgeList *edge_list2=find_edgeList_from_op_to_op(region_ptr,exit_op,to_op2);
                if(edge_list2!=NULL)
                {
                        BEdb(3,"2) edge_id %d",edge_list2->GetEdgeId());
                        e2=_edge_table->find_edge(edge_list2->GetEdgeId());
                        BEdb(2,"2) %d\t%d\t%d\t%d\n",e2->counter_index(),e2->profile(),e2->edge_id(),e2->weight());
                }

                //
                // Step 3. Get exit_op branch target register and 
                //         predicate register
                //
                legoOprd *branch_target_oprd=exit_op->GetSrcOprdPtr();
                legoOprd *predicate_oprd=branch_target_oprd->GetNextOprdPtr();
                assert(predicate_oprd->GetNextOprdPtr()==NULL);

                assert(branch_target_oprd->GetOprdType()==OT_REG);
                assert(branch_target_oprd->GetOprdRegType()==RT_R);
                assert(branch_target_oprd->GetOprdFileType()==FT_BTR);
                assert(branch_target_oprd->GetOprdDataType()==DT_B);
                BEdb(2,"r<%d:b btr>",branch_target_oprd->GetOprdRegNum());
        
                assert(predicate_oprd->GetOprdType()==OT_REG);
                assert(predicate_oprd->GetOprdDataType()==DT_P);
                assert(predicate_oprd->GetOprdFileType()==FT_PR);
                assert(predicate_oprd->GetOprdRegType()==RT_R);
                BEdb(2,"r<%d:p pr>",predicate_oprd->GetOprdRegNum());

                //
                // Step 4. Find PBRR which defines branch_target_oprd
                //
                legoOp *pbrr_op;

                for(pbrr_op=exit_op->GetPrevLink();pbrr_op!=NULL;pbrr_op=pbrr_op->GetPrevLink())
                {
                        if(pbrr_op->GetOpcode()==PBRR)
                                break;
                }

                assert(pbrr_op!=NULL);
                legoOprd *dest_oprd=pbrr_op->GetDestOprdPtr();
                assert(dest_oprd->GetOprdType()==OT_REG);
                assert(dest_oprd->GetOprdRegType()==RT_R);
                assert(dest_oprd->GetOprdFileType()==FT_BTR);
                assert(dest_oprd->GetOprdDataType()==DT_B);

                if(dest_oprd->GetOprdRegNum()!=branch_target_oprd->GetOprdRegNum())
                {
                        assert(0);
                }

                if(edge_list1!=NULL && edge_list2!=NULL)
                {
                        //
                        // Step 5. From source operand of PBRR to know block_id
                        //
                        legoOprd *pbrr_src_oprd=pbrr_op->GetSrcOprdPtr();
                        assert(pbrr_src_oprd->GetOprdType()==OT_LITERAL_CB);
                        int pbrr_block_id=pbrr_src_oprd->GetLiteralControlBlock();
                        BEdb(2,"pbrr_block_id=%d",pbrr_block_id);

                        //
                        // Step 6. Get the entry_ops id for pbrr_block_id
                        //
                        legoRegion *dest_region=find_lego_block_with_region_id(proc_ptr,pbrr_block_id);
                        opList *dest_entry_op_list=dest_region->GetEntryOpsPtr();
                        legoOp *dest_entry_op=dest_entry_op_list->GetOpPtr();
                        int dest_entry_op_id=dest_entry_op->GetOpId();
                        BEdb(2,"dest_entry_op_id=%d",dest_entry_op_id);

                        //
                        // Step 7. set true_path_mapping & false_path_mapping
                        //
                        int true_path_mapping=-1,false_path_mapping=-1;
                        if(to_opid1==dest_entry_op_id)
                        {
                                true_path_mapping=e1->counter_index();
                                false_path_mapping=e2->counter_index();
                        }
                        else if(to_opid2==dest_entry_op_id)
                        {
                                true_path_mapping=e2->counter_index();
                                false_path_mapping=e1->counter_index();
                        }
                        else
                        {
                                assert(0);
                        }

                        //
                        // Step 8. call insert_probe
                        //
                        // FIX
                        _my_instrument.prepend_3_probes(proc_ptr,region_ptr,predicate_oprd,true_path_mapping,false_path_mapping,Predicate::true_predicate_oprd(),exit_op,s_time);


                }
                else
                {
                        //
                        // inside hyperblock
                        //
                        BEdb(2,"Hyperblock");
                        int path_mapping;

                        if(e1!=NULL && e2==NULL)
                        {
                                path_mapping=e1->counter_index();
                        }
                        else if(e2!=NULL && e1==NULL)
                        {
                                path_mapping=e2->counter_index();
                        }
                        else
                        {
                                assert(0);
                        }

                        //
                        // FIX
                        //insert_1_probe(proc_ptr,region_ptr,predicate_oprd,path_mapping,exit_op,"_MY_1_PRoBe");

                        _my_instrument.prepend_save_and_set_1_param_code(path_mapping,proc_ptr,region_ptr,predicate_oprd,exit_op,s_time);
                        _my_instrument.prepend_pbrr_code(BB_EDGE_PROFILE_1_PROBE_NAME,proc_ptr,region_ptr,predicate_oprd,exit_op,s_time);
                        _my_instrument.prepend_brl_code(proc_ptr,region_ptr,predicate_oprd,exit_op,1,s_time);
                        _my_instrument.prepend_restore_1_param_code(proc_ptr,region_ptr,predicate_oprd,exit_op,s_time);


                        //getchar();
                }
        }
        else if(exit_opcode==RTS)
        {
                // Do nothing!!!
        }
        else
        {
                assert(0);
        }
}

/*
//
// Insert 3 probes
// predicate_oprd is used as parameter 1
// Ex:
//
void BB_Edge_Profile::insert_3_probes(legoProc *proc_ptr,legoRegion *region_ptr,legoOprd *predicate_oprd,int true_path_mapping,int false_path_mapping,legoOp* from_op_ptr)
{
        BEdb(2,"true_path_maping=%d false_path_mapping=%d",true_path_mapping,false_path_mapping);

        legoOprd *my_true_predicate_oprd=Predicate::true_predicate_oprd();

        int max_op_id=(FindMaxOpId(proc_ptr))->GetOpId()+1;

        // Ex: Save int_p1 register
        // op 165 (MOVE [r<84:i gpr>] [m<int_p1>] r<38:p pr>)
        //
        legoOp *new_op_ptr=new legoOp(max_op_id++);
        new_op_ptr->SetOpcode(MOVE);
        new_op_ptr->SetSrcOprdPtr(_int_p1_oprd);
        new_op_ptr->SetDestOprdPtr(_save_p1_oprd);
        new_op_ptr->SetPredOprdPtr(my_true_predicate_oprd);

        //WriteOps(new_op_ptr,1,stderr,0);
        insert_new_op_before(region_ptr,proc_ptr,from_op_ptr,new_op_ptr);

        // Ex: Save int_p2 register
        // op 166 (MOVE [r<85:i gpr>] [m<int_p2>] r<38:p pr>)
        //
        new_op_ptr=new legoOp(max_op_id++);
        new_op_ptr->SetOpcode(MOVE);
        new_op_ptr->SetSrcOprdPtr(_int_p2_oprd);
        new_op_ptr->SetDestOprdPtr(_save_p2_oprd);
        new_op_ptr->SetPredOprdPtr(my_true_predicate_oprd);

        //WriteOps(new_op_ptr,1,stderr,0);
        insert_new_op_before(region_ptr,proc_ptr,from_op_ptr,new_op_ptr);

        // Ex: Save int_p3 register
        // op 167 (MOVE [r<86:i gpr>] [m<int_p3>] r<38:p pr>)
        //
        new_op_ptr=new legoOp(max_op_id++);
        new_op_ptr->SetOpcode(MOVE);
        new_op_ptr->SetSrcOprdPtr(_int_p3_oprd);
        new_op_ptr->SetDestOprdPtr(_save_p3_oprd);
        new_op_ptr->SetPredOprdPtr(my_true_predicate_oprd);

        //WriteOps(new_op_ptr,1,stderr,0);
        insert_new_op_before(region_ptr,proc_ptr,from_op_ptr,new_op_ptr);

        // Ex: Set int_p1 to predicate_oprd
        // op 168 (MOVE [m<int_p1>] [r<38:p pr>] p<t>)
        //
        new_op_ptr=new legoOp(max_op_id++);
        new_op_ptr->SetOpcode(MOVE);

        new_op_ptr->SetSrcOprdPtr(predicate_oprd);
        new_op_ptr->SetDestOprdPtr(_int_p1_oprd);
        new_op_ptr->SetPredOprdPtr(my_true_predicate_oprd);

        //WriteOps(new_op_ptr,1,stderr,0);
        insert_new_op_before(region_ptr,proc_ptr,from_op_ptr,new_op_ptr);

        // Ex: Set int_p2 to ture_path_mapping
        // op 169 (MOVE [m<int_p2>] [i<2>] p<t>)
        //
        new_op_ptr=new legoOp(max_op_id++);
        new_op_ptr->SetOpcode(MOVE);

        legoOprd *src_oprd=new legoOprd();
        src_oprd->SetOprdType(OT_LITERAL_I);
        src_oprd->SetLiteralInteger(true_path_mapping);

        new_op_ptr->SetSrcOprdPtr(src_oprd);
        new_op_ptr->SetDestOprdPtr(_int_p2_oprd);
        new_op_ptr->SetPredOprdPtr(my_true_predicate_oprd);

        //WriteOps(new_op_ptr,1,stderr,0);
        insert_new_op_before(region_ptr,proc_ptr,from_op_ptr,new_op_ptr);

        // Ex: Set int_p3 to false_path_mapping
        // op 170 (MOVE [m<int_p3>] [i<1>] p<t>)
        //
        new_op_ptr=new legoOp(max_op_id++);
        new_op_ptr->SetOpcode(MOVE);

        src_oprd=new legoOprd();
        src_oprd->SetOprdType(OT_LITERAL_I);
        src_oprd->SetLiteralInteger(false_path_mapping);

        new_op_ptr->SetSrcOprdPtr(src_oprd);
        new_op_ptr->SetDestOprdPtr(_int_p3_oprd);
        new_op_ptr->SetPredOprdPtr(my_true_predicate_oprd);

        //WriteOps(new_op_ptr,1,stderr,0);
        insert_new_op_before(region_ptr,proc_ptr,from_op_ptr,new_op_ptr);

        // Ex:
        // op 171 (PBRR [r<83:i gpr>] [l:g_abs<_MY_3_PRoBeS>] p<t>) 
        //
        new_op_ptr=new legoOp(max_op_id++);
        new_op_ptr->SetOpcode(PBRR);

        src_oprd=new legoOprd();
        src_oprd->SetOprdType(OT_LITERAL_L);
        src_oprd->SetLiteralLabel("_MY_3_PRoBeS");
        src_oprd->SetLiteralAddrStyle(AS_G_ABS);

        new_op_ptr->SetSrcOprdPtr(src_oprd);
        new_op_ptr->SetDestOprdPtr(_address_oprd);
        new_op_ptr->SetPredOprdPtr(my_true_predicate_oprd);

        //WriteOps(new_op_ptr,1,stderr,0);
        insert_new_op_before(region_ptr,proc_ptr,from_op_ptr,new_op_ptr);

        // Ex:
        // op 172 (BRL [m<ret_addr>] [r<83:i gpr>] p<t> attr(lc ^288) 
        //
        new_op_ptr=new legoOp(max_op_id++);
        new_op_ptr->SetOpcode(BRL);

        new_op_ptr->SetSrcOprdPtr(_address_oprd);
        new_op_ptr->SetDestOprdPtr(_ret_oprd);
        new_op_ptr->SetPredOprdPtr(my_true_predicate_oprd);
        new_op_ptr->SetOpAttrListPtr(_attr_3_list);

        //WriteOps(new_op_ptr,1,stderr,0);
        insert_new_op_before(region_ptr,proc_ptr,from_op_ptr,new_op_ptr);

        // Ex:
        // op 173 (MOVE [m<int_p1>] [r<84:i gpr>] p<t>)
        //
        new_op_ptr=new legoOp(max_op_id++);
        new_op_ptr->SetOpcode(MOVE);

        new_op_ptr->SetSrcOprdPtr(_save_p1_oprd);
        new_op_ptr->SetDestOprdPtr(_int_p1_oprd);
        new_op_ptr->SetPredOprdPtr(my_true_predicate_oprd);

        //WriteOps(new_op_ptr,1,stderr,0);
        insert_new_op_before(region_ptr,proc_ptr,from_op_ptr,new_op_ptr);

        // Ex:
        // op 174 (MOVE [m<int_p2>] [r<85:i gpr>] p<t>)
        //
        new_op_ptr=new legoOp(max_op_id++);
        new_op_ptr->SetOpcode(MOVE);

        new_op_ptr->SetSrcOprdPtr(_save_p2_oprd);
        new_op_ptr->SetDestOprdPtr(_int_p2_oprd);
        new_op_ptr->SetPredOprdPtr(my_true_predicate_oprd);

        //WriteOps(new_op_ptr,1,stderr,0);
        insert_new_op_before(region_ptr,proc_ptr,from_op_ptr,new_op_ptr);

        // Ex:
        // op 175 (MOVE [m<int_p3>] [r<86:i gpr>] p<t>)
        //
        new_op_ptr=new legoOp(max_op_id++);
        new_op_ptr->SetOpcode(MOVE);

        new_op_ptr->SetSrcOprdPtr(_save_p3_oprd);
        new_op_ptr->SetDestOprdPtr(_int_p3_oprd);
        new_op_ptr->SetPredOprdPtr(my_true_predicate_oprd);

        //WriteOps(new_op_ptr,1,stderr,0);
        insert_new_op_before(region_ptr,proc_ptr,from_op_ptr,new_op_ptr);

        //getchar();
}
*/

void BB_Edge_Profile::open_header_file()
{
        _header_fp=fopen(BB_EDGE_HEADER_FILENAME,"r");

        if(_header_fp==NULL)
        {
                _header_fp=fopen(BB_EDGE_HEADER_FILENAME,"w");
                assert(_header_fp!=NULL);

                fprintf(_header_fp," extern void MY_1_PRoBe (int);\n");
                fprintf(_header_fp," extern void MY_3_PRoBeS (int,int,int);\n");
                fprintf(_header_fp," extern void MY_BBiD_eND_PRoBe (int);\n");
                fprintf(_header_fp," extern void MY_BBiD_STaRT_PRoBe (int);\n");
        }
}

void BB_Edge_Profile::close_header_file()
{
        fclose(_header_fp);
}

void BB_Edge_Profile::open_main_file(int bb_max_entry,int edge_max_entry)
{
        _main_fp=fopen(BB_EDGE_MAIN_FILENAME,"w");

        if(_main_fp==NULL)
        {
                fprintf(stderr,"Error open file:%s\n",BB_EDGE_MAIN_FILENAME);
                exit(0);
        }

        fprintf(_main_fp,"/*\n\tFile: %s\n",BB_EDGE_MAIN_FILENAME);
        fprintf(_main_fp,"\tAuthor: Chao-ying Fu\n");
        fprintf(_main_fp,"\tDate: Aug. 28, 1998\n*/\n\n");
        fprintf(_main_fp,"#define bbid_max_entry %u\n",bb_max_entry);
        fprintf(_main_fp,"#define edge_max_entry %u\n\n",edge_max_entry);

        fprintf(_main_fp,"#include <stdio.h>\n\n");

        fprintf(_main_fp,"extern unsigned char global_macro_op[1024];\n");
        fprintf(_main_fp,"extern void MaiN(int argc,char **argv);\n");
        fprintf(_main_fp,"void MY_iNiT();\n");
        fprintf(_main_fp,"void MY_eXiT();\n\n");

        fprintf(_main_fp,"int bbid_counter[bbid_max_entry];\n");
        fprintf(_main_fp,"int edge_counter[edge_max_entry];\n\n");

        fprintf(_main_fp,"char bbid_counter_filename[13]=\"BBiD_CouNTeR\";\n");
        fprintf(_main_fp,"char edge_counter_filename[13]=\"eDGe_CouNTeR\";\n");
        fprintf(_main_fp,"char pair_counter_filename[13]=\"PaiR_CouNTeR\";\n");
        fprintf(_main_fp,"FILE *bbid_counter_fp=NULL;\n");
        fprintf(_main_fp,"FILE *edge_counter_fp=NULL;\n");
        fprintf(_main_fp,"FILE *pair_counter_fp=NULL;\n");
        fprintf(_main_fp,"int bb1;        // for bb end probe\n");
        fprintf(_main_fp,"int bb2;        // for bb start probe\n");
        fprintf(_main_fp,"int number_of_pair;\n");
        fprintf(_main_fp,"#define MAX_EDGE_NUMBER 10000\n\n");

        fprintf(_main_fp,"struct Edge_Entry\n");
        fprintf(_main_fp,"{\n");
        fprintf(_main_fp,"        int bb1;\n");
        fprintf(_main_fp,"        int bb2;\n");
        fprintf(_main_fp,"        int counter;\n");
        fprintf(_main_fp,"        struct Edge_Entry *next;\n");
        fprintf(_main_fp,"} edge_entry[MAX_EDGE_NUMBER];\n\n");

        fprintf(_main_fp,"int main(int argc,char **argv)\n");
        fprintf(_main_fp,"{\n");
        fprintf(_main_fp,"        MY_iNiT();\n");
        fprintf(_main_fp,"        atexit(MY_eXiT);\n");
        fprintf(_main_fp,"        MaiN(argc,argv);\n");
        fprintf(_main_fp,"}\n\n");

        fprintf(_main_fp,"void MY_iNiT()\n");
        fprintf(_main_fp,"{\n");
        fprintf(_main_fp,"        int i;\n");
        fprintf(_main_fp,"        struct Edge_Entry *ee;\n");
        fprintf(_main_fp,"        for(i=0;i<bbid_max_entry;i++)\n");
        fprintf(_main_fp,"        {\n");
        fprintf(_main_fp,"                bbid_counter[i]=0;\n");
        fprintf(_main_fp,"        }\n");
        fprintf(_main_fp,"        for(i=0;i<edge_max_entry;i++)\n");
        fprintf(_main_fp,"        {\n");
        fprintf(_main_fp,"                edge_counter[i]=0;\n");
        fprintf(_main_fp,"        }\n");
        fprintf(_main_fp,"        bbid_counter_fp=fopen(bbid_counter_filename,\"w\");\n");
        fprintf(_main_fp,"        if(bbid_counter_fp==NULL)\n");
        fprintf(_main_fp,"        {\n");
        fprintf(_main_fp,"                fprintf(stderr,\"Error Open File:%%s\\n\",bbid_counter_filename);\n");
        fprintf(_main_fp,"                exit(0);\n");
        fprintf(_main_fp,"         }\n");
        fprintf(_main_fp,"        edge_counter_fp=fopen(edge_counter_filename,\"w\");\n");
        fprintf(_main_fp,"        if(edge_counter_fp==NULL)\n");
        fprintf(_main_fp,"        {\n");
        fprintf(_main_fp,"                fprintf(stderr,\"Error Open File:%%s\\n\",edge_counter_filename);\n");
        fprintf(_main_fp,"                exit(0);\n");
        fprintf(_main_fp,"        }\n");
        fprintf(_main_fp,"        pair_counter_fp=fopen(pair_counter_filename,\"w\");\n");
        fprintf(_main_fp,"        if(pair_counter_fp==NULL)\n");
        fprintf(_main_fp,"        {\n");
        fprintf(_main_fp,"                fprintf(stderr,\"Error Open File:%%s\\n\",pair_counter_filename);\n");
        fprintf(_main_fp,"                exit(0);\n");
        fprintf(_main_fp,"        }\n");
        fprintf(_main_fp,"        bb1=-1;\n");
        fprintf(_main_fp,"        bb2=-1;\n");
        fprintf(_main_fp,"        for(i=0;i<MAX_EDGE_NUMBER;i++)\n");
        fprintf(_main_fp,"        {\n");
        fprintf(_main_fp,"                ee=&edge_entry[i];\n");
        fprintf(_main_fp,"                ee->bb1=-1;\n");
        fprintf(_main_fp,"                ee->next=NULL;\n");
        fprintf(_main_fp,"        }\n");
        fprintf(_main_fp,"        number_of_pair=0;\n");
        fprintf(_main_fp,"}\n\n");

        fprintf(_main_fp,"void MY_eXiT()\n");
        fprintf(_main_fp,"{\n");
        fprintf(_main_fp,"        struct Edge_Entry *ee;\n");
        fprintf(_main_fp,"        int i;\n");
        fprintf(_main_fp,"        for(i=0;i<bbid_max_entry;i++)\n");
        fprintf(_main_fp,"        {\n");
        fprintf(_main_fp,"                fprintf(bbid_counter_fp,\"%%d %%d\\n\",i,bbid_counter[i]);\n");
        fprintf(_main_fp,"        }\n");
        fprintf(_main_fp,"        fclose(bbid_counter_fp);\n");
        fprintf(_main_fp,"        for(i=0;i<edge_max_entry;i++)\n");
        fprintf(_main_fp,"        {\n");
        fprintf(_main_fp,"                fprintf(edge_counter_fp,\"%%d %%d\\n\",i,edge_counter[i]);\n");
        fprintf(_main_fp,"        }\n");
        fprintf(_main_fp,"        fclose(edge_counter_fp);\n");
        fprintf(_main_fp,"        fprintf(pair_counter_fp,\"number_of_pair=%%d\\n\",number_of_pair);\n");
        fprintf(_main_fp,"        for(i=0;i<MAX_EDGE_NUMBER;i++)\n");
        fprintf(_main_fp,"        {\n");
        fprintf(_main_fp,"                ee=&edge_entry[i];\n");
        fprintf(_main_fp,"                if(ee->bb1!=-1)\n");
        fprintf(_main_fp,"                {\n");
        fprintf(_main_fp,"                        do\n");
        fprintf(_main_fp,"                        {\n");
        fprintf(_main_fp,"                                fprintf(pair_counter_fp,\"(%%d,%%d):%%d\\n\",ee->bb1,ee->bb2,ee->counter);\n");
        fprintf(_main_fp,"                                ee=ee->next;\n");
        fprintf(_main_fp,"                        }\n");
        fprintf(_main_fp,"                        while(ee!=NULL);\n");
        fprintf(_main_fp,"                }\n");
        fprintf(_main_fp,"        }\n");
        fprintf(_main_fp,"        fclose(pair_counter_fp);\n");
        fprintf(_main_fp,"}\n\n");

        fprintf(_main_fp,"void MY_1_PRoBe(int mapping)\n");
        fprintf(_main_fp,"{\n");
        fprintf(_main_fp,"        edge_counter[mapping]++;\n");
        fprintf(_main_fp,"}\n\n");

        fprintf(_main_fp,"void MY_3_PRoBeS(int predicate,int true_path_mapping,int false_path_mapping)\n");
        fprintf(_main_fp,"{\n");
        fprintf(_main_fp,"        if(predicate==1)\n");
        fprintf(_main_fp,"        {\n");
        fprintf(_main_fp,"                edge_counter[true_path_mapping]++;\n");
        fprintf(_main_fp,"        }\n");
        fprintf(_main_fp,"        else if(predicate==0)\n");
        fprintf(_main_fp,"        {\n");
        fprintf(_main_fp,"                edge_counter[false_path_mapping]++;\n");
        fprintf(_main_fp,"        }\n");
        fprintf(_main_fp,"        else\n");
        fprintf(_main_fp,"        {\n");
        fprintf(_main_fp,"                fprintf(stderr,\"ERROR! predicate %%d\\n\",predicate);\n");
        fprintf(_main_fp,"                exit(0);\n");
        fprintf(_main_fp,"        }\n");
        fprintf(_main_fp,"}\n\n");

        fprintf(_main_fp,"void MY_BBiD_eND_PRoBe(int mapping)\n");
        fprintf(_main_fp,"{\n");
        fprintf(_main_fp,"        bb1=mapping;\n");
        fprintf(_main_fp,"}\n\n");

        fprintf(_main_fp,"void MY_BBiD_STaRT_PRoBe(int mapping)\n");
        fprintf(_main_fp,"{\n");
        fprintf(_main_fp,"        struct Edge_Entry *ee,*last_ee;\n");
        fprintf(_main_fp,"        int index;\n");
        fprintf(_main_fp,"        bbid_counter[mapping]++;\n");
        fprintf(_main_fp,"        bb2=mapping;\n");
        fprintf(_main_fp,"        if(bb1>=100000)\n");
        fprintf(_main_fp,"        {\n");
        fprintf(_main_fp,"                bb1=bb1-100000;\n");
        fprintf(_main_fp,"                index=(bb1+bb2)%%MAX_EDGE_NUMBER;\n");
        fprintf(_main_fp,"                ee=&edge_entry[index];\n");
        fprintf(_main_fp,"                //\n");
        fprintf(_main_fp,"                // Search (bb1,bb2)\n");
        fprintf(_main_fp,"                //\n");
        fprintf(_main_fp,"                if(ee->bb1==-1)\n");
        fprintf(_main_fp,"                {\n");
        fprintf(_main_fp,"                        //\n");
        fprintf(_main_fp,"                        // not match, put it to this ee\n");
        fprintf(_main_fp,"                        //\n");
        fprintf(_main_fp,"                        ee->bb1=bb1;\n");
        fprintf(_main_fp,"                        ee->bb2=bb2;\n");
        fprintf(_main_fp,"                        ee->counter=1;\n");
        fprintf(_main_fp,"                        number_of_pair++;\n");
        fprintf(_main_fp,"                }\n");
        fprintf(_main_fp,"                else if(ee->bb1==bb1 && ee->bb2==bb2)\n");
        fprintf(_main_fp,"                {\n");
        fprintf(_main_fp,"                        // match, increment\n");
        fprintf(_main_fp,"                        ee->counter++;\n");
        fprintf(_main_fp,"                }\n");
        fprintf(_main_fp,"                else\n");
        fprintf(_main_fp,"                {\n");
        fprintf(_main_fp,"                        // search bucket\n");
        fprintf(_main_fp,"                        last_ee=ee;\n");
        fprintf(_main_fp,"                        ee=ee->next;\n");
        fprintf(_main_fp,"                        while(ee!=NULL)\n");
        fprintf(_main_fp,"                        {\n");
        fprintf(_main_fp,"                                if(ee->bb1==bb1 && ee->bb2==bb2)\n");
        fprintf(_main_fp,"                                        break;\n");
        fprintf(_main_fp,"                                last_ee=ee;\n");
        fprintf(_main_fp,"                                ee=ee->next;\n");
        fprintf(_main_fp,"                        }\n");
        fprintf(_main_fp,"                        if(ee!=NULL)\n");
        fprintf(_main_fp,"                        {\n");
        fprintf(_main_fp,"                                // match\n");
        fprintf(_main_fp,"                                ee->counter++;\n");
        fprintf(_main_fp,"                        }\n");
        fprintf(_main_fp,"                        else\n");
        fprintf(_main_fp,"                        {\n");
        fprintf(_main_fp,"                                // create new ee\n");
        fprintf(_main_fp,"                                ee=(struct Edge_Entry *)malloc(sizeof(struct Edge_Entry));\n");
        fprintf(_main_fp,"                                last_ee->next=ee;\n");
        fprintf(_main_fp,"                                ee->bb1=bb1;\n");
        fprintf(_main_fp,"                                ee->bb2=bb2;\n");
        fprintf(_main_fp,"                                ee->counter=1;\n");
        fprintf(_main_fp,"                                ee->next=NULL;\n");
        fprintf(_main_fp,"                                // increment number_of_pair\n");
        fprintf(_main_fp,"                                number_of_pair++;\n");
        fprintf(_main_fp,"                        }\n");
        fprintf(_main_fp,"                }\n");
        fprintf(_main_fp,"                // Reset bb1\n");
        fprintf(_main_fp,"                bb1=-1;\n");
        fprintf(_main_fp,"        }\n");
        fprintf(_main_fp,"}\n");
}

void BB_Edge_Profile::close_main_file()
{
        fclose(_main_fp);
}

---