if (OPT_ClassLoaderProxy.proxy.includesType(rhs.type, use.type) == YES)
if (OPT_ClassLoaderProxy.includesType(rhs.type, use.type) == YES)
  static void typePropagation (OPT_IR ir) {    // Use register list to enumerate register objects (FAST)    OPT_Register elemNext;    for (OPT_Register reg = ir.regpool.getFirstRegister(); reg != null;         reg = elemNext) {      elemNext = (OPT_Register)reg.getNext();      // Type propagation not possible if reg has no uses      if (reg.useList == null)        continue;      // Type propagation not possible if reg has no defs      if (reg.defList == null)        continue;      // Do not attempt type propagation if reg has multiple defs      if (!reg.isSSA())        continue;      // Now reg has exactly one definition      OPT_RegisterOperand lhs = reg.defList;      OPT_Instruction instr = lhs.instruction;      OPT_Operator op = instr.operator();      // Type propagation not possible if lhs is not in a move instr      if (!op.isMove())        continue;      OPT_Operand rhsOp = Move.getVal(instr);      // Do not attempt type propagation if RHS is not a register      if (!(rhsOp instanceof OPT_RegisterOperand))        continue;      OPT_RegisterOperand rhs = (OPT_RegisterOperand)rhsOp;      // Propagate the type in the def      lhs.type = rhs.type;      // Now propagate lhs into all uses; substitute rhs.type for lhs.type      for (OPT_RegisterOperand use = reg.useList; use != null;           use = (OPT_RegisterOperand)use.getNext()) {        // if rhs.type is a supertype of use.type, don't do it        // because use.type has more detailed information        if (OPT_ClassLoaderProxy.proxy.includesType(rhs.type, use.type) == YES)          continue;	// If VM_Magic has been employed to convert an int to a reference, 	// don't undo the effects!	if (rhs.type.isPrimitiveType() && !use.type.isPrimitiveType())	  continue;        use.type = rhs.type;      }    }  }