Ejemplo n.º 1
0
void Function::comput_succ_pred_BB(){
  
  list<Basic_block*>::iterator it, it2;
  Basic_block *current;
  Instruction *instr;
  Basic_block *succ=NULL;
  // IMPORTANT ne pas enlever la ligne ci-dessous 
  if (BB_pred_succ) return;
  int size= (int) _myBB.size();
  it=_myBB.begin();
  current=*it;
  cout<<"debut comput succ pred bb"<<endl;

  for (int i=0; i<size; i++){
    current=*it;
    it2 = it;
    
    instr = (Instruction*)current->get_branch();

    if(instr != NULL) {
      if(instr->get_opcode() != j && instr->get_opcode() != jal && instr->get_opcode() != jalr  && instr->get_opcode() != jr){

	Basic_block* suc1 = find_label_BB(instr->get_op_label());
	it2++;
	Basic_block *suc2 = *it2;
	current->set_link_succ_pred(suc1);
	current->set_link_succ_pred(suc2);
      }
      else{

	if(instr->get_opcode() == j){
	  Basic_block *suc = find_label_BB(instr->get_op_label()); 
	  current->set_link_succ_pred(suc);
	}
	else {
	  if(instr->is_call()){
	    it2++;
	    Basic_block *suc = *it2;
	    current->set_link_succ_pred(suc);
	  }
	}
      } 
      it++;
    }
    else {
      it++;
      Basic_block *tmp = *it;
      if(tmp != NULL)
	current->set_link_succ_pred(tmp); 
    }
  }
  cout<<"fin comput succ pred bb"<<endl;
  // ne pas enlever la ligne ci-dessous
  BB_pred_succ = true;
  return;
}
Ejemplo n.º 2
0
// NB : penser  utiliser la méthode set_link_succ_pred(Basic_block *) de la classe Basic_block  
void Function::comput_succ_pred_BB(){
  
   list<Basic_block*>::iterator it, it2;
   Basic_block *current;
   Instruction *instr;
   int nbi;
   Operand* op;
   
   Basic_block *succ=NULL;
   
   int size= (int) _myBB.size(); // nombre de BB
   it=_myBB.begin();   //1er BB
   //remarque : le dernier block n'a pas de successeurs
 
   for(int i=0; i<size-1; i++) {
     current = *it;
     instr = current->get_instruction_at_index(current->get_nb_inst()-2);

     // si saut
     if(instr->is_branch()) {
       // saut conditionnel
       if(instr->is_cond_branch()) {
	 // ajout suivant
	 current->set_link_succ_pred(*(++it));
	 // label = op3
	 op = instr->get_op3();
       }
       else {
	 // label = op1
	 op = instr->get_op1();
	 it++;
       }
       // ajout du label
       succ = find_label_BB((dynamic_cast<OPLabel * > (op)));
       current->set_link_succ_pred(succ);
     } else {
       // pas de saut, ajout suivant
       current->set_link_succ_pred(*(++it));
     }
   }
   
   
   //A REMPLIR
   

}
Ejemplo n.º 3
0
void Function::compute_live_var(){
 
  int size=(int)_myBB.size();
  list<Basic_block*> blocNoSucc;
  list<Basic_block*> workinglist;
  list<Basic_block*>::iterator it;
  Basic_block *current;
  it=_myBB.begin();  
  bool* reg=(bool*)malloc(sizeof(bool)*size);
  cout <<"debut compute_live_var"<< endl;
  //Trouver les blocs sans successeurs
  for(int i = 0; i < size; i++){
    current = *it;
    reg[i] = false;
    if(current->get_nb_succ() == 0){
      blocNoSucc.push_back(current);
    }
    it++;
  }
  //LiveIn = Use
  while(!blocNoSucc.empty()) {
   current = blocNoSucc.front(); 
   blocNoSucc.pop_front();
   reg[current->get_index()]=true;
   for(int j = 0;j<NB_REG;j++) {
     current->LiveIn[j] = current->Use[j];
   }
   for(int p = 0;p<current->get_nb_pred();p++) {
     workinglist.push_back(current->get_predecessor(p));
   }
  }
  while(!workinglist.empty()) {
   current = workinglist.front(); 
   workinglist.pop_front();
   if(reg[current->get_index()]) {
     continue;
   }
   else {
     reg[current->get_index()] = true;
   }
   //Calcul de LiveOut
   if(current->get_successor1() != NULL) {
     for(int k = 0;k<NB_REG;k++) {
       if(current->get_successor1()->LiveIn[k]){
	 current->LiveOut[k] = current->get_successor1()->LiveIn[k];
       }
     }
   }
   if(current->get_successor2() != NULL) {
     for(int l = 0;l<NB_REG;l++) {
       if(current->get_successor2()->LiveIn[l]){
	 current->LiveOut[l] = current->get_successor2()->LiveIn[l];
       }
     }
   }
   //Calcul de LiveIn
   for(int m = 0;m<NB_REG;m++) {
     if(current->Use[m]) {
       current->LiveIn[m] = current->Use[m];
     }
   }
   for(int n = 0;n<NB_REG;n++) {
     if(!current->Def[n]) {
       if(current->LiveOut[n]) {
	 current->LiveIn[n] = current->LiveOut[n];
       }
     }
   }
    for(int q = 0;q<current->get_nb_pred();q++) {
      workinglist.push_back(current->get_predecessor(q));
    }
    
  }
 cout <<"fin compute_live_var"<< endl;
  return;
}
Ejemplo n.º 4
0
int main(int argc, char * argv[]){

	if (argc < 2) {
	  cout << "erreur : pas de fichier assembleur" << endl;
	}	  
	Program prog(argv[1]);
	Function* functmp;
	list <Function*> myfunc; 
	list <Basic_block*> myBB;

	cout<<"Le programme a "<<prog.size()<<" lignes\n"<<endl;

	prog.comput_function();
	cout<<"nombre de fonctions : "<<prog.nbr_func()<<endl;

	list<Function*>::iterator itfct;
	list<Basic_block*>::iterator itbb;
	Basic_block *bb;
	int i, j;
	list<int> frees;
	Dfg *d;
	Cfg *c;
	
	std::ostringstream *oss ;
	for(itfct=prog.function_list_begin(), i=0;
	    itfct!=prog.function_list_end(); itfct++, i++){
	   functmp=*itfct;
	    cout<<"------------Function DISPLAY----------\n" <<endl;
	    functmp->display();
	   functmp->comput_basic_block();
	   functmp->comput_label();
	   functmp->comput_succ_pred_BB();
	   
	   oss=new std::ostringstream;
	   
	   (*oss)<<"./tmp/func_"<<i<<".dot";
	   c=new Cfg(functmp->get_BB(0), functmp->nbr_BB());
	   c->restitution(NULL, oss->str());
	   
	   cout<<"========== Function "<<i<<"==========="<<endl;
	   cout<<"============================"<<endl;
	   
	   functmp ->compute_live_var();
	   j=0;
	   int total1 = 0, total2 = 0, total3 = 0, total4 = 0;
	   for(itbb=functmp->bb_list_begin(); 
	       itbb!=functmp->bb_list_end(); itbb++, j++){
	      bb=*itbb;
	      bb->link_instructions();
	      bb->comput_pred_succ_dep();

	      total1 += bb->nb_cycles();
	      d = new Dfg(bb);
	      d->scheduling(false);
	      d->apply_scheduling();
	      total2 += bb->nb_cycles();

	      bb->reg_rename();
	      // il faut annuler le calcul des dépendances et le refaire
	      bb->reset_pred_succ_dep();
	      bb->comput_pred_succ_dep();
	      total3 += bb->nb_cycles();

	      d= new Dfg(bb);
	      d->scheduling(false);
	      d->apply_scheduling();

	      total4 += bb->nb_cycles();
	      //return 0;
	   }
	   printf("Nombres de cycles : \n");
	   printf(" BASIC  | SCHEDULED | RENAMED | RE-SCHEDULED\n");
	   printf("   %d   |    %d     |    %d   |     %d      \n", total1, total2, total3, total4);
	}
	    
	
	

	
}
Ejemplo n.º 5
0
void Function::comput_succ_pred_BB(){
	list <Basic_block*> BBtmp;
	Basic_block * BB = new Basic_block();
	

	/*Calcul des successeurs*/
	for(int i=0; i<_myBB.size(); i++){
		BB = get_BB(i);
		if(get_BB(i)->get_end()->get_line()->type_line()==line_Instru){
			//si l'instru n'est pas un br alors 1 successeur le BB suivant
			if(get_BB(i)->get_branch()==NULL && ((i+1) < _myBB.size()) ||
				dynamic_cast< Instruction *> (get_BB(i)->get_branch()->get_line())->get_opcode()==jal ||
				dynamic_cast< Instruction *> (get_BB(i)->get_branch()->get_line())->get_opcode()==jalr  ){
				BB->set_successor1( get_BB(i+1)); 
				}
	
			//si l'instru est un BR inconditiennel 1 successeur le BB pointé par le label
			else if(dynamic_cast< Instruction *> (get_BB(i)->get_branch()->get_line())->get_opcode()==j){ 
				if(find_label_BB(dynamic_cast< Instruction *> (get_BB(i)->get_branch()->get_line())->get_op1())->get_head()){
					//cout<<"coucou1"<<endl;
					BB->set_successor1(find_label_BB(
					  dynamic_cast< Instruction *> (get_BB(i)->get_branch()->get_line())->get_op1()));
				}
			}//cout<<"here too\n";}
	
			//si l'instru est un BR conditionnel 2 successeur le BB pointé et le BB suivant
			else if((dynamic_cast< Instruction *> (get_BB(i)->get_branch()->get_line())->get_opcode()==beq ||
				dynamic_cast< Instruction *> (get_BB(i)->get_branch()->get_line())->get_opcode()==bne)
				&& ((i+1)< _myBB.size())){
			
				if(find_label_BB(
					dynamic_cast< Instruction *> (get_BB(i)->get_branch()->get_line())->get_op3())->get_head()){	
					
					BB->set_successor1(find_label_BB( dynamic_cast< Instruction *> (get_BB(i)->get_branch()->get_line())->get_op3()));
				}
				BB->set_successor2(get_BB(i+1));
				//cout<<"here too too\n";
			}
	
			else if(dynamic_cast< Instruction *> (get_BB(i)->get_branch()->get_line())->get_opcode()!=jr
					&& ((i+1)< _myBB.size())){

				if(find_label_BB(
					dynamic_cast< Instruction *> (get_BB(i)->get_branch()->get_line())->get_op2())->get_head()){
					
					BB->set_successor1(find_label_BB(
					dynamic_cast< Instruction *> (get_BB(i)->get_branch()->get_line())->get_op2()));
				}
				BB->set_successor2(get_BB(i+1));
				//cout<<"and finaly here too\n";
			}

			//sinon pas de successeur
			else ;
			BBtmp.push_back(BB);
			BB = new Basic_block();
		}
		

	}
	_myBB.clear();

	list<Basic_block*>::iterator it;
	it=BBtmp.begin();

	for (int i=0; i< BBtmp.size();i++ ){ 
		_myBB.push_back(*it);
		it++;
	}

	/*Calcul des predecesseur*/
	for(int i=0;i<_myBB.size(); i++){
		for(int j=0; j<_myBB.size(); j++){
			//cout<<"nbr de succ de BB"<<j<<" "<<get_BB(j)->get_nbr_succ()<<endl;
			if(get_BB(j)->get_nbr_succ()){
				if(get_BB(i)->get_index() == get_BB(j)->get_successor1()->get_index()){
					get_BB(i)->set_predecessor(get_BB(j));
				}
			}
			if(get_BB(j)->get_nbr_succ()==2){
				if(get_BB(i)->get_index() == get_BB(j)->get_successor2()->get_index()){
						get_BB(i)->set_predecessor(get_BB(j));	
				}
			}
		}		
	}	
	
}
Ejemplo n.º 6
0
void Function::comput_basic_block(){
	Basic_block * BB = new Basic_block();	
	int i=0;
	int begin=0;

		Node* element = _head;

		//cout<<"entré"<<endl;
		/*supprime les directives precedent le premier BB*/
		while(!begin){
			if(element->get_line()->type_line()!=line_Direct){
				//cout<<"tete1 "<<element->get_line()->get_content() <<endl;
				BB->set_head(element);
				//cout<<BB->get_head()->get_line()->get_content()<<endl;
				begin=1;
			}	
			else	element= element->get_next();

		}

		while(element != _end)
		{ 		/*si l'instruction est un branchement alors on prend le delay sot comme
				dernier element du BB et comme tete l'element qui suit*/
			if(element->get_line()->type_line()==line_Instru && element->get_next()->get_line()->type_line()==line_Instru){
				if(element->get_line()->get_type()==BR){
					//cout<<"fin1 "<<element->get_next()->get_line()->get_content() <<endl;
					BB->set_branch(element);
					BB->set_end(element->get_next());
					BB->set_index(i);
					i++;
					_myBB.push_back(BB);
					BB = new Basic_block();
					BB->set_branch(NULL);
					if(element->get_next()->get_next()!=_end && element->get_next()!=_end){
						//cout<<"tête2 "<<element->get_next()->get_next()->get_line()->get_content() <<endl;
						BB->set_head(element->get_next()->get_next());
						element = element->get_next();
					}
					else	break;
				}
			}
			/*si l'instruction suivante est un label alors on prend l'instruction courante comme fin
			du BB et on prens le suivant comme tete du prochain BB*/
			else if(element->get_next()->get_line()->type_line()==line_Lab){
				//cout<<"fin3 "<<element->get_line()->get_content() <<endl;
				BB->set_end(element);
				BB->set_index(i);
				i++;
				_myBB.push_back(BB);
				//cout<<"tête3 "<<element->get_next()->get_line()->get_content() <<endl;
				BB = new Basic_block();
				BB->set_head(element->get_next());

			}
			if(element->get_next()==_end){
				BB->set_end(element);
				BB->set_index(i);
				i++;
				//cout<<"fin4"<<element->get_line()->get_content() <<endl;
				_myBB.push_back(BB);
				break;
			}
			else element = element->get_next();

		}	


		
}