Patch title: i386 optimizer v24
Abstract:
Enhancements to the core optimizer for i386.
File: /pliant/language/compiler/argument/argument.c
Key:
    Removed line
    Added line
   
// Copyright  Hubert Tonneau  hubert.tonneau@pliant.cx
//
// This program is free software; you can redistribute it an
// modify it under the terms of the GNU General Public Licen
// as published by the Free Software Foundation.
// 
// This program is distributed in the hope that it will be u
// but WITHOUT ANY WARRANTY; without even the implied warran
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public
// version 2 along with this program; if not, write to the F
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA


// Copyright  Hubert Tonneau  hubert.tonneau@pliant.cx
//
// This program is free software; you can redistribute it an
// modify it under the terms of the GNU General Public Licen
// as published by the Free Software Foundation.
// 
// This program is distributed in the hope that it will be u
// but WITHOUT ANY WARRANTY; without even the implied warran
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public
// version 2 along with this program; if not, write to the F
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA


FUNCTION Bool Argument_is_shared_with_instruction(struct Argument *arg1,struct Instruction *instr) {
  Int index;
  for(index=0;index<instr->arguments.nb;index++) {
    if(Argument_is_shared(arg1,(struct Argument *)Array_get_index(&instr->arguments,index)))
      return true; }
  return false; }


// MAX: does this catch all cases? (see optimize_remove_nouse_instructions)
FUNCTION Bool Argument_is_shared_or_dependent(struct Argument *arg1,struct Argument *arg2) {
  if(arg1==arg2)
    return true;
  while(arg1->where==Argument_indirect)
    arg1=arg1->u.indirect.pointer;
  while(arg2->where==Argument_indirect)
    arg2=arg2->u.indirect.pointer;
  if(arg1==arg2)
    return true;
  if(arg1->where!=arg2->where)
    return false;
  if(arg1->where==Argument_constant)
    return arg1->u.constant==arg2->u.constant;
  if(arg1->where==Argument_register)
    return arg1->u.cpu_register==arg2->u.cpu_register;
  return false; }

FUNCTION Bool Argument_is_shared_or_dependent_with_instruction(struct Argument *arg1,struct Instruction *instr) {
  Int index;
  for(index=0;index<instr->arguments.nb;index++) {
    if(Argument_is_shared_or_dependent(arg1,(struct Argument *)Array_get_index(&instr->arguments,index)))
      return true; }
  return false; }

INLINE Bool Argument_is_dependent(struct Argument *arg1,struct Argument *arg2) {
  return !Argument_is_shared(arg1,arg2) &&
    Argument_is_shared_or_dependent(arg1,arg2); }

FUNCTION Bool Argument_is_dependent_with_instruction(struct Argument *arg1,struct Instruction *instr) {
  Int index;
  for(index=0;index<instr->arguments.nb;index++) {
    if(Argument_is_dependent(arg1,(struct Argument *)Array_get_index(&instr->arguments,index)))
      return true; }
  return false; }

FUNCTION Bool Argument_is_dependent_on_ESP(struct Argument *arg1) {
  while(arg1->where==Argument_indirect)
    arg1=arg1->u.indirect.pointer;
  if(arg1->where==Argument_register && arg1->u.cpu_register==Register_ESP)
    return true;
  return false; }

FUNCTION struct Argument *Argument_copy(struct Argument *src
  struct Argument *dest;
  dest=(struct Argument *)Relation_query(relation,src,null);
  if(dest==null) {
    dest=entry_new(G.type_Argument);
    Relation_define(relation,src,null,dest);
    Argument_locate(dest,src->type,src->where);
    switch(dest->where) {
      case Argument_constant:
        Arrow_copy((Arrow *)&src->u.constant,(Arrow *)&dest-
        break;
      case Argument_register:
        dest->u.cpu_register=src->u.cpu_register;
        break;
      case Argument_indirect:
        Arrow_set((Arrow *)&dest->u.indirect.pointer,Argumen
        dest->u.indirect.offset=src->u.indirect.offset;
        break;
      case Argument_a_register:
        dest->u.possible_registers=src->u.possible_registers
        break; }
    Str_copy(&src->name,&dest->name);
    List_copy(&src->requires,&dest->requires); }
  return dest; }



FUNCTION Void Argument2_destroy(struct Argument2 *arg2) {
  Arrow_destroy((Arrow *)&arg2->argument); }
FUNCTION struct Argument *Argument_copy(struct Argument *src
  struct Argument *dest;
  dest=(struct Argument *)Relation_query(relation,src,null);
  if(dest==null) {
    dest=entry_new(G.type_Argument);
    Relation_define(relation,src,null,dest);
    Argument_locate(dest,src->type,src->where);
    switch(dest->where) {
      case Argument_constant:
        Arrow_copy((Arrow *)&src->u.constant,(Arrow *)&dest-
        break;
      case Argument_register:
        dest->u.cpu_register=src->u.cpu_register;
        break;
      case Argument_indirect:
        Arrow_set((Arrow *)&dest->u.indirect.pointer,Argumen
        dest->u.indirect.offset=src->u.indirect.offset;
        break;
      case Argument_a_register:
        dest->u.possible_registers=src->u.possible_registers
        break; }
    Str_copy(&src->name,&dest->name);
    List_copy(&src->requires,&dest->requires); }
  return dest; }



FUNCTION Void Argument2_destroy(struct Argument2 *arg2) {
  Arrow_destroy((Arrow *)&arg2->argument); }