Author: mberg
Date: 2011-04-18 14:42:38 -0400 (Mon, 18 Apr 2011)
New Revision: 3557
Modified:
trunk/osprey/be/cg/cg.cxx
trunk/osprey/be/cg/cg_flags.cxx
trunk/osprey/be/cg/cg_flags.h
trunk/osprey/be/cg/cgdriver.cxx
trunk/osprey/be/cg/ebo_special.h
trunk/osprey/be/cg/oputil.cxx
trunk/osprey/be/cg/x8664/cgemit_targ.cxx
trunk/osprey/be/cg/x8664/cgtarget.cxx
trunk/osprey/be/cg/x8664/ebo_special.cxx
trunk/osprey/common/targ_info/isa/x8664/isa.cxx
trunk/osprey/common/targ_info/isa/x8664/isa_operands.cxx
trunk/osprey/common/targ_info/isa/x8664/isa_pack.cxx
trunk/osprey/common/targ_info/isa/x8664/isa_print.cxx
trunk/osprey/common/targ_info/isa/x8664/isa_properties.cxx
trunk/osprey/common/targ_info/isa/x8664/isa_subset.cxx
trunk/osprey/common/targ_info/proc/x8664/barcelona_si.cxx
trunk/osprey/common/targ_info/proc/x8664/core_si.cxx
trunk/osprey/common/targ_info/proc/x8664/em64t_si.cxx
trunk/osprey/common/targ_info/proc/x8664/opteron_si.cxx
trunk/osprey/common/targ_info/proc/x8664/orochi_si.cxx
trunk/osprey/common/targ_info/proc/x8664/wolfdale_si.cxx
Log:
Additions of CG based SIB address mode functionality under the control of
-CG:merge_counters_x86=<on,off>, where initially this check in is off by
default.
Code Reviewed by Jian-Xin.
Modified: trunk/osprey/be/cg/cg.cxx
===================================================================
--- trunk/osprey/be/cg/cg.cxx 2011-04-16 09:01:45 UTC (rev 3556)
+++ trunk/osprey/be/cg/cg.cxx 2011-04-18 18:42:38 UTC (rev 3557)
@@ -1490,6 +1490,18 @@
GRA_LIVE_Rename_TNs();
#if !defined(TARG_PPC32) // PPC IGLS_Schedule_Region bugs
IGLS_Schedule_Region (TRUE /* before register allocation */);
+#ifdef TARG_X8664
+ void Counter_Merge (char*);
+ if (CG_merge_counters_x86 == TRUE && CG_opt_level > 1) {
+ if (Enable_CG_Peephole) {
+ Set_Error_Phase ( "SIB counter merging" );
+ GRA_LIVE_Recalc_Liveness(region ? REGION_get_rid( rwn) : NULL);
+ GRA_LIVE_Rename_TNs ();
+ Counter_Merge (Cur_PU_Name);
+ }
+ }
+#endif
+
#endif
#endif // TARG_SL
Modified: trunk/osprey/be/cg/cg_flags.cxx
===================================================================
--- trunk/osprey/be/cg/cg_flags.cxx 2011-04-16 09:01:45 UTC (rev 3556)
+++ trunk/osprey/be/cg/cg_flags.cxx 2011-04-18 18:42:38 UTC (rev 3557)
@@ -125,6 +125,7 @@
BOOL CG_branch_fuse = TRUE;
BOOL CG_dispatch_schedule = FALSE;
BOOL CG_strcmp_expand = TRUE;
+BOOL CG_merge_counters_x86 = FALSE;
#endif
BOOL CG_opt_level;
BOOL CG_localize_tns = FALSE;
Modified: trunk/osprey/be/cg/cg_flags.h
===================================================================
--- trunk/osprey/be/cg/cg_flags.h 2011-04-16 09:01:45 UTC (rev 3556)
+++ trunk/osprey/be/cg/cg_flags.h 2011-04-18 18:42:38 UTC (rev 3557)
@@ -533,6 +533,7 @@
extern BOOL CG_128bitstore;
extern BOOL CG_branch_fuse;
extern BOOL CG_strcmp_expand;
+extern BOOL CG_merge_counters_x86;
#endif
extern INT CG_opt_level;
extern BOOL CG_localize_tns;
Modified: trunk/osprey/be/cg/cgdriver.cxx
===================================================================
--- trunk/osprey/be/cg/cgdriver.cxx 2011-04-16 09:01:45 UTC (rev 3556)
+++ trunk/osprey/be/cg/cgdriver.cxx 2011-04-18 18:42:38 UTC (rev 3557)
@@ -475,6 +475,8 @@
0, 0, 0, &CG_branch_fuse, NULL },
{ OVK_BOOL, OV_VISIBLE, TRUE, "strcmp_expand", "",
0, 0, 0, &CG_strcmp_expand, NULL },
+ { OVK_BOOL, OV_VISIBLE, TRUE, "merge_counters_x86", "",
+ 0, 0, 0, &CG_merge_counters_x86, NULL },
#endif
{ OVK_BOOL, OV_INTERNAL, TRUE, "skip_local_sched", "",
0, 0, 0, &CG_skip_local_sched, NULL },
Modified: trunk/osprey/be/cg/ebo_special.h
===================================================================
--- trunk/osprey/be/cg/ebo_special.h 2011-04-16 09:01:45 UTC (rev 3556)
+++ trunk/osprey/be/cg/ebo_special.h 2011-04-18 18:42:38 UTC (rev 3557)
@@ -206,6 +206,8 @@
void Init_Load_Exec_Map( BB*, MEM_POOL* );
BOOL Delete_Unwanted_Prefetches( OP* );
BOOL EBO_Can_Eliminate_Zero_Opnd_OP(OP *);
+void Counter_Merge();
+void Peel_Spills();
#endif /* TARG_X8664 */
BOOL EBO_Can_Merge_Into_Offset (OP *op);
Modified: trunk/osprey/be/cg/oputil.cxx
===================================================================
--- trunk/osprey/be/cg/oputil.cxx 2011-04-16 09:01:45 UTC (rev 3556)
+++ trunk/osprey/be/cg/oputil.cxx 2011-04-18 18:42:38 UTC (rev 3557)
@@ -2041,6 +2041,8 @@
{TOP_ldupdxx, TOP_vldupdxx},
{TOP_ldupd_n32, TOP_vldupd_n32},
{TOP_ldups, TOP_vldups},
+ {TOP_ldupsx, TOP_vldupsx},
+ {TOP_ldupsxx, TOP_vldupsxx},
{TOP_ldups_n32, TOP_vldups_n32},
{TOP_stdqu, TOP_vstdqu},
{TOP_stdqu_n32, TOP_vstdqu_n32},
@@ -2048,6 +2050,8 @@
{TOP_sthps, TOP_vsthps},
{TOP_stlpd, TOP_vstlpd},
{TOP_sthpd, TOP_vsthpd},
+ {TOP_sthpdx, TOP_vsthpdx},
+ {TOP_sthpdxx, TOP_vsthpdxx},
{TOP_stlps_n32, TOP_vstlps_n32},
{TOP_sthps_n32, TOP_vsthps_n32},
{TOP_stlpd_n32, TOP_vstlpd_n32},
Modified: trunk/osprey/be/cg/x8664/cgemit_targ.cxx
===================================================================
--- trunk/osprey/be/cg/x8664/cgemit_targ.cxx 2011-04-16 09:01:45 UTC (rev
3556)
+++ trunk/osprey/be/cg/x8664/cgemit_targ.cxx 2011-04-18 18:42:38 UTC (rev
3557)
@@ -3539,6 +3539,8 @@
OP_Name[TOP_ldupdxx] = "movupd";
OP_Name[TOP_ldupd_n32] = "movupd";
OP_Name[TOP_ldups] = "movups";
+ OP_Name[TOP_ldupsx] = "movups";
+ OP_Name[TOP_ldupsxx] = "movups";
OP_Name[TOP_ldups_n32] = "movups";
OP_Name[TOP_movss] = "movaps";
OP_Name[TOP_movdq] = "movdqa";
Modified: trunk/osprey/be/cg/x8664/cgtarget.cxx
===================================================================
--- trunk/osprey/be/cg/x8664/cgtarget.cxx 2011-04-16 09:01:45 UTC (rev
3556)
+++ trunk/osprey/be/cg/x8664/cgtarget.cxx 2011-04-18 18:42:38 UTC (rev
3557)
@@ -392,6 +392,8 @@
case TOP_ldaps:
case TOP_ldaps_n32:
case TOP_ldups:
+ case TOP_ldupsx:
+ case TOP_ldupsxx:
case TOP_ldups_n32:
case TOP_ldupd:
case TOP_ldupdx:
@@ -444,6 +446,8 @@
case TOP_vldaps:
case TOP_vldaps_n32:
case TOP_vldups:
+ case TOP_vldupsx:
+ case TOP_vldupsxx:
case TOP_vldups_n32:
case TOP_vldupd:
case TOP_vldupdx:
Modified: trunk/osprey/be/cg/x8664/ebo_special.cxx
===================================================================
--- trunk/osprey/be/cg/x8664/ebo_special.cxx 2011-04-16 09:01:45 UTC (rev
3556)
+++ trunk/osprey/be/cg/x8664/ebo_special.cxx 2011-04-18 18:42:38 UTC (rev
3557)
@@ -126,6 +126,15 @@
#include "config_lno.h"
+#include <iostream>
+#include <string>
+#include <sstream>
+#include <set>
+#include <vector>
+#include <list>
+#include <deque>
+#include <map>
+
extern BOOL TN_live_out_of( TN*, BB* );
extern void Set_flags_strcmp_expand();
@@ -4533,6 +4542,7 @@
{TOP_UNDEFINED, TOP_ldsd, TOP_ldsdx, TOP_ldsdxx, TOP_ldsd_n32},
{TOP_UNDEFINED, TOP_lddqa, TOP_lddqax, TOP_lddqaxx, TOP_lddqa_n32},
{TOP_UNDEFINED, TOP_ldupd, TOP_ldupdx, TOP_ldupdxx, TOP_UNDEFINED},
+ {TOP_UNDEFINED, TOP_ldups, TOP_ldupsx, TOP_ldupsxx, TOP_ldups_n32},
{TOP_UNDEFINED, TOP_lddqu, TOP_lddqux, TOP_lddquxx, TOP_UNDEFINED},
{TOP_UNDEFINED, TOP_ldlps, TOP_ldlpsx, TOP_ldlpsxx, TOP_ldlps_n32},
{TOP_UNDEFINED, TOP_ldlpd, TOP_ldlpdx, TOP_ldlpdxx, TOP_UNDEFINED},
@@ -4590,6 +4600,8 @@
{TOP_UNDEFINED, TOP_prefetcht0, TOP_prefetcht0x, TOP_prefetcht0xx,
TOP_UNDEFINED},
{TOP_UNDEFINED, TOP_prefetcht1, TOP_prefetcht1x, TOP_prefetcht1xx,
TOP_UNDEFINED},
+ {TOP_UNDEFINED, TOP_prefetchnta, TOP_prefetchntax, TOP_prefetchntaxx,
TOP_UNDEFINED},
+ {TOP_UNDEFINED, TOP_sthpd, TOP_sthpdx, TOP_sthpdxx, TOP_sthpd_n32},
// LEA
{TOP_UNDEFINED, TOP_lea32, TOP_leax32, TOP_leaxx32, TOP_UNDEFINED},
{TOP_UNDEFINED, TOP_lea64, TOP_leax64, TOP_leaxx64, TOP_UNDEFINED},
@@ -5126,6 +5138,915 @@
return TOP_UNDEFINED;
}
+
+bool
+Test_if_base_mode (OP* op) {
+ //function that banks on the number of operands to figure
+ // out if the BASE MODE is being used
+ ADDR_MODE mode = BASE_MODE;
+ const TOP new_top = Get_Top_For_Addr_Mode(OP_code(op), mode);
+ if (new_top == OP_code(op)) {
+ if (OP_store(op) || OP_load(op) || OP_prefetch(op))
+ return true;
+
+ if (OP_load_exe(op)) {
+ if (OP_icmp(op)) {
+ // Some integer compares are not easy to convert to SIB
+ return false;
+ }
+ if (OP_opnds(op) > 3) {
+ return false;
+ } else if (OP_opnds(op) == 2 || OP_opnds(op) == 3) {
+ if (OP_results(op) == 1) {
+ return true;
+ } else {
+ return false;
+ }
+ } else {
+ return false;
+ }
+ } else {
+ return false;
+ }
+ } else {
+ return false;
+ }
+}
+
+OP *
+Compose_Mem_Base_Index_Mode ( OP* op, TN* index, TN* offset, TN* scale, TN*
base )
+{
+ // Based on existing function
+ Is_True( offset != NULL, ("Compose_Mem_Base_Index_Mode: offset is NULL") );
+ Is_True( index != NULL, ("Compose_Mem_Base_Index_Mode: index is NULL") );
+ Is_True( scale != NULL, ("Compose_Mem_Base_Index_Mode: scale is NULL") );
+ Is_True( base != NULL, ("Compose_Mem_Base_Index_Mode: base is NULL") );
+ OP* new_op = NULL;
+ ADDR_MODE mode = BASE_INDEX_MODE;
+ const TOP new_top = Get_Top_For_Addr_Mode(OP_code(op), mode);
+ FmtAssert( new_top != TOP_UNDEFINED, ("Compose_Mem_Op: unknown top") );
+ if( TOP_is_prefetch( new_top ) ){
+ new_op = Mk_OP( new_top, OP_opnd( op, 0 ), base, offset, index, scale );
+ } else {
+ TN* storeval = NULL;
+
+ if( TOP_is_store(new_top) ){
+ storeval = OP_opnd( op, OP_find_opnd_use( op, OU_storeval ) );
+ } else {
+ storeval = OP_result( op, 0 );
+ }
+ if (OP_load(op) || OP_store(op) || OP_prefetch(op)) {
+ new_op = Mk_OP( new_top, storeval, base, offset, index, scale );
+ } else if (OP_load_exe(op)) {
+ if (OP_opnds(op) == 2) {
+ FmtAssert ((storeval != NULL),
+ ("Unsupported storeval with operands == 2 || == 1"));
+ new_op = Mk_OP( new_top, storeval, base, index, scale, offset );
+ return new_op;
+ } else if (OP_opnds(op) == 3) {
+ FmtAssert ((storeval != NULL),
+ ("Unsupported storeval with operands >2"));
+ new_op = Mk_OP( new_top, storeval,
+ OP_opnd(op,0), base, index, scale, offset );
+ return new_op;
+ }
+ FmtAssert(0,("Unsupported for Compose_Mem_Base_Index_Mode\n"));
+ } else {
+ FmtAssert(0,("Unsupported for Compose_Mem_Base_Index_Mode\n"));
+ }
+ }
+ Copy_WN_For_Memory_OP(new_op, op);
+ if (OP_volatile(op)) // Bug 4245 - copy "volatile" flag
+ Set_OP_volatile(new_op);
+ OP_srcpos(new_op) = OP_srcpos(op);
+
+ Set_OP_unrolling(new_op, OP_unrolling(op));
+ Set_OP_orig_idx(new_op, OP_map_idx(op));
+ Set_OP_unroll_bb(new_op, OP_unroll_bb(op));
+
+ return new_op;
+}
+
+static bool histogram_of_index_counters (
+ std::set<TN*> counted_base_regs,
+ std::map<int,std::list<OP*> >& val_lis_map,
+ std::map<TN*,OP*> add_map) {
+ if (counted_base_regs.size() < 3)
+ return false;
+ std::set<TN*>::const_iterator counted_base_regs_it;
+ for (counted_base_regs_it = counted_base_regs.begin();
+ counted_base_regs_it != counted_base_regs.end();
+ ++counted_base_regs_it) {
+ OP* add_op_c = add_map[*counted_base_regs_it];
+ TN* constant_tn = OP_opnd(add_op_c,1);
+ val_lis_map[TN_value(constant_tn)].push_front(add_op_c);
+ }
+
+ if (val_lis_map.size() != 1) {
+ return false;
+ } else if (val_lis_map.begin()->first < 4) {
+ return false;
+ }
+ return true;
+}
+
+static bool test_change_affects_flags (
+ std::set<TN*> counted_base_regs,
+ std::map<TN*,OP*> add_map) {
+ std::set<TN*>::const_iterator counted_base_regs_it;
+ for (counted_base_regs_it = counted_base_regs.begin();
+ counted_base_regs_it != counted_base_regs.end();
+ ++counted_base_regs_it) {
+ OP* whc = add_map[*counted_base_regs_it];
+ bool anychange = false;
+ for (OP *tesop = OP_next(whc);
+ tesop != NULL;
+ tesop = OP_next(tesop)) {
+ TOP top = OP_code(tesop);
+ if (OP_reads_rflags(tesop)) {
+ return true;
+ }
+ if (TOP_is_change_rflags(top)) {
+ anychange = true;
+ break;
+ }
+ }
+ if (anychange == false)
+ return false;
+ }
+ return false;
+}
+
+static bool collect_counters (bool pdom_header,
+ bool compare_undo, BB *fromwhere,
+ GTN_SET* otherliveins, std::map<TN*, bool>& avoid_table,
+ std::set<TN*>& seen_defs, std::set<TN*>& used_at_all,
+ std::map<TN*, OP*>& add_map, BB** add_bb,
+ std::map<TN*,std::deque<OP*> >& use_map,
+ std::map<TN*, OP*>& compare_map,
+ std::set<TN*>& compare_opnds) {
+ OP* op;
+ op = BB_first_op(fromwhere);
+ int insnum = 0;
+ while(op != NULL) {
+ // avoid_table holds operands for which
+ // SIB is not to be done
+ // known defs tracks all defs along the
+ // traversed control flow path
+ for (INT i = 0; i < OP_opnds(op); ++i) {
+ if (avoid_table.find(OP_opnd(op,i)) == avoid_table.end()) {
+ avoid_table[OP_opnd(op,i)] = false;
+ }
+ }
+ for (INT i = 0; i < OP_results(op); ++i) {
+ if (avoid_table.find(OP_result(op,i)) == avoid_table.end()) {
+ avoid_table[OP_result(op,i)] = false;
+ }
+ }
+ std::ostringstream reason;
+ {
+ bool doesnotapply = false;
+ if (OP_load_exe(op) || OP_load(op)
+ || OP_store(op) || OP_prefetch(op)) {
+ if (Test_if_base_mode(op) == false) {
+ doesnotapply = true;
+ } else if (!(TN_has_value(OP_opnd(op,
+ OP_find_opnd_use(op,OU_offset))))) {
+ doesnotapply = true;
+ }
+ } else {
+ if (pdom_header) {
+ if (compare_undo) {
+ if (!(OP_iadd(op) &&
+ (OP_result(op,0) == OP_opnd(op,0) &&
+ (TN_is_constant((OP_opnd(op,1)))))) &&
+ !((OP_code(op) == TOP_cmp64) &&
+ (TN_is_register(OP_opnd(op,1)) == TRUE) &&
+ (TN_is_register(OP_opnd(op,0)) == TRUE)) &&
+ !((OP_code(op) == TOP_cmp32)
+ && (TN_is_register(OP_opnd(op,1)) == TRUE) &&
+ (TN_is_register(OP_opnd(op,0)) == TRUE))) {
+ doesnotapply = true;
+ }
+ } else {
+ if (!(OP_iadd(op) &&
+ (OP_result(op,0) == OP_opnd(op,0) &&
+ (TN_is_constant((OP_opnd(op,1))))))) {
+ doesnotapply = true;
+ }
+ }
+ } else {
+ doesnotapply = true;
+ }
+ }
+ if (doesnotapply) {
+ //
+ // cases for which SIB is not applicable
+ // we need to ensure that the registers
+ // used in these cases are not used in
+ // a SIB situation (simplifying assumption)
+ // add operands to the avoid_table
+ //
+ for (INT i = 0; i < OP_opnds(op); ++i) {
+ avoid_table[OP_opnd(op,i)] = true;
+ }
+ for (INT i = 0; i < OP_results(op); ++i) {
+ avoid_table[OP_result(op,i)] = true;
+ }
+ } else {
+ if (OP_load_exe(op) || OP_load(op)
+ || OP_store(op) || OP_prefetch(op)) {
+ for (INT i = 0; i < OP_results(op); ++i) {
+ avoid_table[OP_result(op,i)] = true;
+ }
+ TN* which_base = OP_opnd(op,
+ TOP_Find_Operand_Use(OP_code(op), OU_base));
+
+ for (INT i = 0; i < OP_opnds(op); ++i) {
+ if (OP_opnd(op,i) != which_base) {
+ avoid_table[OP_opnd(op,i)] = true;
+ }
+ }
+ if (avoid_table[which_base] == false) {
+ used_at_all.insert(which_base);
+ // This will not replace an exiting mapping
+ use_map[which_base].push_front(op);
+ }
+ } else if (pdom_header && OP_iadd(op)
+ && (OP_result(op,0) == OP_opnd(op,0)
+ && (TN_is_constant((OP_opnd(op,1)))))) {
+ FmtAssert((OP_results(op) == 1),
+ ("Add operation with more than one result"));
+ if (avoid_table[OP_result(op,0)] == false) {
+ if (otherliveins != NULL) {
+ if (GTN_SET_MemberP(otherliveins,
+ OP_result(op,0)) == 0) {
+ if (*add_bb == NULL)
+ *add_bb = op->bb;
+ if (*add_bb != op->bb)
+ return false;
+ add_map[OP_result(op,0)] = op;
+ if (seen_defs.find (OP_result(op,0))
+ == seen_defs.end())
+ seen_defs.insert(OP_result(op,0));
+ else
+ avoid_table[OP_result(op,0)] = true;
+ } else {
+ // Some SIB like counters are
+ // used outside the loop. we need
+ // a special case fix for these.
+ // as of now we don't enable
+ // SIB for these.
+ reason << " reason:LiveOut variable";
+ avoid_table[OP_result(op,0)] = true;
+ }
+ } else {
+ if (*add_bb == NULL)
+ *add_bb = op->bb;
+ if (*add_bb != op->bb) {
+ return false;
+ }
+
+ add_map[OP_result(op,0)] = op;
+ if (seen_defs.find (OP_result(op,0))
+ == seen_defs.end())
+ seen_defs.insert(OP_result(op,0));
+ else
+ avoid_table[OP_result(op,0)] = true;
+ }
+ }
+ } else if (compare_undo && (OP_code(op) == TOP_cmp64
+ || OP_code(op) == TOP_cmp32)) {
+ for (INT i = 0; i < OP_opnds(op); ++i) {
+ if (TN_is_register(OP_opnd(op,i))) {
+ if (avoid_table[OP_opnd(op,i)] == false) {
+ if (otherliveins != NULL) {
+ if (GTN_SET_MemberP(otherliveins,
+ OP_result(op,0)) == 0) {
+ if (compare_map.find(OP_opnd(op,i)) ==
compare_map.end()) {
+ compare_map[OP_opnd(op,i)] = op;
+
compare_opnds.insert(OP_opnd(op,i));
+ } else {
+ avoid_table[OP_opnd(op,i)] = true;
+ }
+ } else {
+ avoid_table[OP_opnd(op,i)] = true;
+ }
+ } else {
+ if (compare_map.find(OP_opnd(op,i)) ==
compare_map.end()) {
+ compare_map[OP_opnd(op,i)] = op;
+ compare_opnds.insert(OP_opnd(op,i));
+ } else {
+ avoid_table[OP_opnd(op,i)] = true;
+ }
+ }
+ }
+ }
+ }
+ } else {
+ if (pdom_header || compare_undo) {
+ return false;
+ } else {
+ for (INT i = 0; i < OP_opnds(op); ++i) {
+ avoid_table[OP_opnd(op,i)] = true;
+ }
+ for (INT i = 0; i < OP_results(op); ++i) {
+ avoid_table[OP_result(op,i)] = true;
+ }
+ }
+ }
+ }
+ }
+ op = OP_next(op);
+ insnum++;
+ }
+ return true;
+}
+
+static void fix_base_instructions (char* Cur_PU_Name,
+ LOOP_DESCR* loop, GTN_SET* otherliveins) {
+ std::map<TN*, bool> avoid_table;
+ std::set<TN*> seen_defs;
+ std::set<TN*> used_at_all;
+ std::map<TN*, OP*> add_map;
+ std::map<TN*,std::deque<OP*> > use_map;
+ std::set<OP*> dep_map;
+ std::set<TN*> counted_base_regs;
+ std::map<TN*, OP*> compare_map;
+ std::set<TN*> compare_opnds;
+ BB *lhead;
+ lhead = LOOP_DESCR_loophead(loop);
+ BB *add_bb;
+ BB *abbinloop;
+ OP *opi;
+ bool outofhere = false;
+ add_bb = NULL;
+ FOR_ALL_BB_SET_members(LOOP_DESCR_bbset(loop), abbinloop) {
+ bool pdom_header = false;
+ bool compare_undo = false;
+ if (BS_MemberP(BB_pdom_set(lhead), BB_id(abbinloop))) {
+ pdom_header = true;
+ } else {
+ pdom_header = false;
+ }
+
+ if (collect_counters (pdom_header,
+ compare_undo && pdom_header, abbinloop,
+ otherliveins, avoid_table,
+ seen_defs, used_at_all,
+ add_map, &add_bb, use_map,
+ compare_map, compare_opnds) == false) {
+ outofhere == true;
+ break;
+ }
+ }
+
+ if (outofhere) {
+ return;
+ } else if (add_bb == NULL) {
+ return;
+ }
+
+ for (std::set<TN*>::iterator sdit =
+ seen_defs.begin(); sdit != seen_defs.end(); ++sdit) {
+ if (avoid_table[*sdit] == false) {
+ if (used_at_all.find(*sdit) != used_at_all.end()) {
+ counted_base_regs.insert(*sdit);
+ }
+ }
+ }
+
+ //
+ // find out the implications of reordering the add instruction
+ // We do a walk on the counted_base_regs, get the use_map
+ // for each such reg, and check if the def is either
+ // dominating or post-dominating it. If it is dominating it,
+ // we dont need compensation code for it. If it is post-dominating
+ // and the new inc's location is not post-dominating it,
+ // then we need compensation code for the use.
+ //
+
+ std::set<TN*>::iterator cbreg_it;
+ std::set<TN*> skip_set;
+ for (cbreg_it = counted_base_regs.begin();
+ cbreg_it != counted_base_regs.end();
+ ++cbreg_it) {
+ std::map<TN*, std::deque<OP*> >::iterator use_map_it;
+ if (add_map.find(*cbreg_it) == add_map.end()) {
+ skip_set.insert (*cbreg_it);
+ }
+ }
+
+ for (std::set<TN*>::iterator skip_it = skip_set.begin();
+ skip_it != skip_set.end(); ++skip_it) {
+ counted_base_regs.erase(*skip_it);
+ }
+
+
+ for (cbreg_it = counted_base_regs.begin();
+ cbreg_it != counted_base_regs.end();
+ ++cbreg_it) {
+ OP* defing_ins = add_map[*cbreg_it];
+ BB* defing_bb = defing_ins->bb;
+
+ std::deque<OP*>::iterator use_deq_it;
+ for (use_deq_it = use_map[*cbreg_it].begin();
+ use_deq_it != use_map[*cbreg_it].end();
+ ++use_deq_it) {
+ BB* where_used = (*use_deq_it)->bb;
+ if (defing_bb == where_used) {
+ bool usefirst = true;
+ for (OP* whichop = *use_deq_it;
+ whichop != NULL;
+ whichop = OP_prev(whichop)) {
+ if (whichop == defing_ins) {
+ usefirst = false;
+ break;
+ }
+ }
+ if (usefirst == true)
+ dep_map.insert (*use_deq_it);
+ }
+ }
+ }
+
+ std::map<int,std::list<OP*> > val_lis_map;
+ if (histogram_of_index_counters (counted_base_regs,
+ val_lis_map, add_map) == false) {
+ return;
+ }
+
+ if (test_change_affects_flags (counted_base_regs,
+ add_map) == true) {
+ return;
+ }
+
+ OP* add_template = val_lis_map.begin()->second.front();
+ if (counted_base_regs.size() == 0) {
+ return;
+ } else {
+ TN* newinc;
+ newinc = OP_opnd(add_template,1);
+ if (TN_value(newinc) <= 0 ) {
+ return;
+ }
+ }
+
+ TN* newinc;
+ if (Is_Target_32bit()) {
+ newinc = Gen_Literal_TN (TN_value(OP_opnd(add_template,1)), 4);
+ } else {
+ newinc = Gen_Literal_TN (TN_value(OP_opnd(add_template,1)), 8);
+ }
+ OP* newadd;
+ TN* newres = Build_TN_Like(OP_result(add_template,0));
+ Set_TN_is_global_reg(newres);
+ TOP alea;
+ if (Is_Target_32bit()) {
+ alea = TOP_lea32;
+ } else {
+ alea = TOP_lea64;
+ }
+ newadd = Mk_OP(alea, newres, newres, newinc);
+ newadd->bb = add_bb;
+ BB_Prepend_Op(add_bb,newadd);
+ bool aft_prnt = false;
+ std::set<TN*>::const_iterator counted_base_regs_it;
+ std::set<OP*> changed_ops;
+ for (counted_base_regs_it = counted_base_regs.begin();
+ counted_base_regs_it != counted_base_regs.end();
+ ++counted_base_regs_it) {
+ std::deque<OP*> used_ops;
+ used_ops = use_map[(*counted_base_regs_it)];
+ std::deque<OP*>::iterator used_ops_it;
+ for (used_ops_it = used_ops.begin();
+ used_ops_it != used_ops.end();
+ ++used_ops_it) {
+ OP* whatnow;
+ OP* newadd;
+ OP* newmovop;
+ TN *movtn;
+ TN* scale;
+ if( Is_Target_32bit() ){
+ scale = Gen_Literal_TN(1,4);
+ } else {
+ scale = Gen_Literal_TN(1,8);
+ }
+
+ TN* offset_d;
+ if (dep_map.find(*used_ops_it) == dep_map.end()) {
+ if (Is_Target_32bit()) {
+ offset_d = Gen_Literal_TN (TN_value(OP_opnd(*used_ops_it,
+ TOP_Find_Operand_Use(OP_code(*used_ops_it),
+ OU_offset))), 4);
+ } else {
+ offset_d = Gen_Literal_TN (TN_value(OP_opnd(*used_ops_it,
+ TOP_Find_Operand_Use(OP_code(*used_ops_it),
+ OU_offset))), 4);
+ }
+ } else {
+ if( Is_Target_32bit() ){
+ offset_d = Gen_Literal_TN (
+ TN_value(OP_opnd(*used_ops_it,
+ TOP_Find_Operand_Use(
+ OP_code(*used_ops_it), OU_offset)))
+ - TN_value(newinc), 4);
+ } else {
+ offset_d = Gen_Literal_TN (
+ TN_value(OP_opnd(*used_ops_it,
+ TOP_Find_Operand_Use(
+ OP_code(*used_ops_it), OU_offset)))
+ - TN_value(newinc), 8);
+ }
+ }
+
+ whatnow = Compose_Mem_Base_Index_Mode(*used_ops_it,
+ newres, offset_d, scale,
+ OP_opnd(*used_ops_it,
+ TOP_Find_Operand_Use(OP_code(*used_ops_it),
+ OU_base)));
+ OP_scycle(whatnow) = OP_scycle(*used_ops_it);
+
+ BB_Insert_Op_Before((*used_ops_it)->bb,*used_ops_it,whatnow);
+ whatnow->bb = (*used_ops_it)->bb;
+ changed_ops.insert(whatnow);
+ OPS_Remove_Op(&((*used_ops_it)->bb->ops), *used_ops_it);
+ }
+ }
+
+ for (counted_base_regs_it = counted_base_regs.begin();
+ counted_base_regs_it != counted_base_regs.end();
+ ++counted_base_regs_it) {
+ OP* anaddop = add_map[*counted_base_regs_it];
+ BB_Remove_Op(anaddop->bb,anaddop);
+ }
+
+ std::set<OP*>::iterator changed_ops_it;
+ bool enable_large_disp_opt = false;
+ std::set<OP*> large_disp_ops;
+ if (enable_large_disp_opt) {
+ for (changed_ops_it = changed_ops.begin();
+ changed_ops_it != changed_ops.end();
+ ++changed_ops_it) {
+ TN* theofst = OP_opnd(*changed_ops_it,
+ TOP_Find_Operand_Use(OP_code(*changed_ops_it),
+ OU_offset));
+ FmtAssert ((TN_is_constant(theofst)),
+ ("Not a constant offset\n"));
+ INT64 theval = TN_value(theofst);
+ // make a new lea op Mk_Op
+ if (theval < 127)
+ if (theval > -128)
+ continue;
+ TOP alea;
+ TN* zeroval;
+ if (Is_Target_32bit()) {
+ zeroval = Gen_Literal_TN (0,4);
+ alea = TOP_lea32;
+ } else {
+ zeroval = Gen_Literal_TN (0,8);
+ alea = TOP_lea64;
+ }
+ TN* thebase = OP_opnd(*changed_ops_it,
+ TOP_Find_Operand_Use(OP_code(*changed_ops_it),
+ OU_base));
+ TN* newgprtn = Build_TN_Like(thebase);
+ OP* thelea = Mk_OP(alea, newgprtn, thebase, theofst);
+ INT offset_loc, base_loc;
+ offset_loc = TOP_Find_Operand_Use(OP_code(*changed_ops_it),
+ OU_offset);
+ base_loc = TOP_Find_Operand_Use(OP_code(*changed_ops_it),
+ OU_base);
+ Set_OP_opnd(*changed_ops_it, offset_loc, zeroval);
+ Set_OP_opnd(*changed_ops_it, base_loc, newgprtn);
+ large_disp_ops.insert(thelea);
+ }
+ }
+
+ BBLIST* predlis = BB_preds(LOOP_DESCR_loophead(loop));
+ bool inserted_some = false;
+ while (predlis) {
+ BB *pred = BBLIST_item(predlis);
+ predlis = BBLIST_next(predlis);
+ if (!BB_SET_MemberP(LOOP_DESCR_bbset(loop), pred)) {
+ inserted_some = true;
+ OP* init_co;
+ TN* zeroval;
+ TOP whichldc;
+ if( Is_Target_32bit()) {
+ zeroval = Gen_Literal_TN (0,4);
+ whichldc = TOP_ldc32;
+ } else {
+ whichldc = TOP_ldc64;
+ zeroval = Gen_Literal_TN (0,8);
+ }
+ init_co = Mk_OP (whichldc, newres, zeroval , newres);
+ if (BB_branch_op(pred)) {
+ BB_Insert_Op_Before(pred,BB_branch_op(pred),init_co);
+ init_co->bb = pred;
+ std::set<OP*>::iterator init_ops_it;
+ if (enable_large_disp_opt) {
+ for (init_ops_it = large_disp_ops.begin();
+ init_ops_it != large_disp_ops.end();
+ ++init_ops_it) {
+ OP* toinse;
+ toinse = Mk_OP (OP_code(*init_ops_it),
+ OP_result (*init_ops_it,0),
+ OP_opnd (*init_ops_it,0),
+ OP_opnd (*init_ops_it,1));
+ BB_Insert_Op_Before(pred,BB_branch_op(pred),toinse);
+ }
+ }
+ } else {
+ BB_Append_Op(pred,init_co);
+ init_co->bb = pred;
+ std::set<OP*>::iterator init_ops_it;
+ if (enable_large_disp_opt) {
+ for (init_ops_it = large_disp_ops.begin();
+ init_ops_it != large_disp_ops.end();
+ ++init_ops_it) {
+ OP* toinse;
+ toinse = Mk_OP (OP_code(*init_ops_it),
+ OP_result (*init_ops_it,0),
+ OP_opnd (*init_ops_it,0),
+ OP_opnd (*init_ops_it,1));
+ BB_Append_Op(pred,toinse);
+ }
+ }
+ }
+ }
+ }
+ FmtAssert(inserted_some == true,
+ ("No init instruction inserted!"));
+ GRA_LIVE_Recalc_Liveness (NULL);
+}
+
+static void fix_compare_binding (LOOP_DESCR* loop,
+ GTN_SET* otherliveins) {
+ std::map<TN*, bool> avoid_table;
+ std::set<TN*> seen_defs;
+ std::set<TN*> used_at_all;
+ std::map<TN*, OP*> add_map;
+ std::map<TN*,std::deque<OP*> > use_map;
+ std::set<OP*> dep_map;
+ std::set<TN*> counted_base_regs;
+ std::map<TN*, OP*> compare_map;
+ std::set<TN*> compare_opnds;
+ BB *lhead;
+ lhead = LOOP_DESCR_loophead(loop);
+ BB *add_bb;
+ add_bb = NULL;
+ BB *abbinloop;
+ OP *opi;
+ bool outofhere = false;
+ FOR_ALL_BB_SET_members(LOOP_DESCR_bbset(loop), abbinloop) {
+ bool pdom_header = false;
+ bool compare_undo = true;
+ if (BS_MemberP(BB_pdom_set(lhead), BB_id(abbinloop))) {
+ pdom_header = true;
+ } else {
+ pdom_header = false;
+ }
+
+ if (collect_counters (pdom_header,
+ compare_undo && pdom_header, abbinloop,
+ otherliveins, avoid_table,
+ seen_defs, used_at_all,
+ add_map, &add_bb, use_map,
+ compare_map, compare_opnds) == false) {
+ outofhere == true;
+ break;
+ }
+ }
+
+ if (outofhere) {
+ return;
+ } else if (add_bb == NULL) {
+ return;
+ }
+
+ // additional checks
+ for (std::set<TN*>::iterator sdit =
+ seen_defs.begin(); sdit != seen_defs.end(); ++sdit) {
+ if (avoid_table[*sdit] == false) {
+ if (used_at_all.find(*sdit) != used_at_all.end()) {
+ counted_base_regs.insert(*sdit);
+ }
+ }
+ }
+
+ //
+ // find out the implications of reordering the add instruction
+ // We do a walk on the counted_base_regs, get the use_map
+ // for each such reg, and check if the def is either
+ // dominating or post-dominating it. If it is dominating it,
+ // we dont need compensation code for it. If it is post-dominating
+ // and the new inc's location is not post-dominating it,
+ // then we need compensation code for the use.
+ //
+
+ std::set<TN*>::iterator cbreg_it;
+ std::set<TN*> skip_set;
+ // additional checks
+ for (cbreg_it = counted_base_regs.begin();
+ cbreg_it != counted_base_regs.end();
+ ++cbreg_it) {
+ std::map<TN*, std::deque<OP*> >::iterator use_map_it;
+ if (add_map.find(*cbreg_it) == add_map.end()) {
+ skip_set.insert (*cbreg_it);
+ }
+ }
+
+ for (std::set<TN*>::iterator skip_it = skip_set.begin();
+ skip_it != skip_set.end(); ++skip_it) {
+ counted_base_regs.erase(*skip_it);
+ }
+
+ std::map<int,std::list<OP*> > val_lis_map;
+ if (histogram_of_index_counters (counted_base_regs,
+ val_lis_map, add_map) == false) {
+ return;
+ }
+
+ if (test_change_affects_flags (counted_base_regs,
+ add_map) == true) {
+ return;
+ }
+
+ int cardinale = 0;
+ std::set<TN*> interset;
+ for (std::set<TN*>::iterator comit =
+ compare_opnds.begin(); comit != compare_opnds.end(); ++comit) {
+ if (counted_base_regs.find(*comit) != counted_base_regs.end()) {
+ cardinale++;
+ interset.insert(*comit);
+ }
+ }
+
+ if (cardinale != 1) {
+ for (std::set<TN*>::iterator comit =
+ compare_opnds.begin(); comit != compare_opnds.end(); ++comit) {
+ counted_base_regs.erase (*comit);
+ }
+ } else {
+ TN* bound_name = *(interset.begin());
+ counted_base_regs.erase (bound_name);
+ TOP whichmov;
+ TN* homing_gr;
+ if (Is_Target_32bit()) {
+ whichmov = TOP_mov32;
+ } else {
+ whichmov = TOP_mov64;
+ }
+ homing_gr = Build_TN_Like(bound_name);
+ OP* new_add_op;
+ TOP add_opcod;
+ if (Is_Target_32bit()) {
+ add_opcod = TOP_addi32;
+ } else {
+ add_opcod = TOP_addi64;
+ }
+
+ new_add_op = Mk_OP(add_opcod, homing_gr, homing_gr,
+ OP_opnd(add_map[bound_name],1));
+ BB_Insert_Op_Before (add_bb, add_map[bound_name], new_add_op);
+ OP_scycle(new_add_op) = OP_scycle(add_map[bound_name]);
+ new_add_op->bb = add_bb;
+
+ FOR_ALL_BB_SET_members(LOOP_DESCR_bbset(loop), abbinloop) {
+ FOR_ALL_BB_OPs (abbinloop,opi) {
+ if (opi != compare_map [bound_name]
+ && opi != add_map[bound_name]) {
+ for (int i = 0; i < OP_opnds(opi); i++) {
+ if (OP_opnd(opi,i) == bound_name)
+ Set_OP_opnd (opi, i, homing_gr);
+ }
+ for (int i = 0; i < OP_results(opi); i++) {
+ if (OP_result(opi,i) == bound_name)
+ Set_OP_result (opi, i, homing_gr);
+ }
+ }
+ }
+ }
+
+ use_map[homing_gr] = use_map[bound_name];
+ use_map.erase(bound_name);
+ add_map[homing_gr] = new_add_op;
+ add_map.erase(bound_name);
+ counted_base_regs.insert (homing_gr);
+ counted_base_regs.erase (bound_name);
+
+ BBLIST* predlis = BB_preds(LOOP_DESCR_loophead(loop));
+ while (predlis) {
+ BB *pred = BBLIST_item(predlis);
+ predlis = BBLIST_next(predlis);
+ if (!BB_SET_MemberP(LOOP_DESCR_bbset(loop), pred)) {
+ if (BB_branch_op(pred)) {
+ OP* homing_mov;
+ homing_mov = Mk_OP(whichmov, homing_gr, bound_name);
+ BB_Insert_Op_Before (pred, BB_branch_op(pred),
homing_mov);
+ homing_mov->bb = pred;
+ } else {
+ OP* homing_mov;
+ homing_mov = Mk_OP(whichmov, homing_gr, bound_name);
+ BB_Append_Op(pred,homing_mov);
+ homing_mov->bb = pred;
+ }
+ }
+ }
+ GRA_LIVE_Recalc_Liveness (NULL);
+ }
+}
+
+void Counter_Merge (char *Cur_PU_Name) {
+ GRA_LIVE_Recalc_Liveness (NULL);
+ MEM_POOL loop_descr_pool;
+ MEM_POOL_Initialize(&loop_descr_pool, "loop_descriptors", TRUE);
+ MEM_POOL_Push (&loop_descr_pool);
+ Calculate_Dominators();
+
+ LOOP_DESCR *theloops = LOOP_DESCR_Detect_Loops(&loop_descr_pool);
+ for (LOOP_DESCR *loop = theloops; loop; loop = LOOP_DESCR_next(loop)) {
+ if (!BB_innermost(LOOP_DESCR_loophead(loop)))
+ continue;
+ BB *abbinloop;
+ OP *opi;
+ bool dontdoit = false;
+ FOR_ALL_BB_SET_members(LOOP_DESCR_bbset(loop), abbinloop) {
+ FOR_ALL_BB_OPs (abbinloop,opi) {
+ // escape hatch for loops that hold volatile
+ // registers or have calls. calls may modify
+ // contents of SIB registers
+ if (OP_volatile(opi))
+ dontdoit = true;
+ if (OP_call(opi))
+ dontdoit = true;
+ }
+ }
+ if (dontdoit) continue;
+
+ //
+ // collect the LiveIn sets of pdoms of loop header
+ // which are not part of the loop
+ //
+ GTN_SET* otherliveins;
+ otherliveins = NULL;
+ MEM_POOL merge_counter_pool;
+ MEM_POOL_Initialize(&merge_counter_pool,
+ "loop_descriptors", TRUE);
+ MEM_POOL_Push (&merge_counter_pool);
+
+ // We collect the live-ins of successors of the loop BBs
+ // which are not part of the loop.
+ // We will avoid doing SIB for the variables which are
+ // part of that live-in set
+ FOR_ALL_BB_SET_members(LOOP_DESCR_bbset(loop), abbinloop) {
+ BBLIST* succlis = BB_succs(abbinloop);
+ while (succlis) {
+ BB *succ = BBLIST_item(succlis);
+ succlis = BBLIST_next(succlis);
+ if (!BB_SET_MemberP(LOOP_DESCR_bbset(loop), succ)) {
+ if (otherliveins == NULL) {
+ otherliveins = BB_live_in(succ);
+ } else {
+ otherliveins = GTN_SET_Union (otherliveins,
+ BB_live_in (succ), &merge_counter_pool);
+ }
+ }
+ }
+ }
+
+ fix_compare_binding (loop, otherliveins);
+
+ // collect otherliveins again as fix_compare_binding may have
+ // changed liveness
+ otherliveins = NULL;
+ FOR_ALL_BB_SET_members(LOOP_DESCR_bbset(loop), abbinloop) {
+ BBLIST* succlis = BB_succs(abbinloop);
+ while (succlis) {
+ BB *succ = BBLIST_item(succlis);
+ succlis = BBLIST_next(succlis);
+ if (!BB_SET_MemberP(LOOP_DESCR_bbset(loop), succ)) {
+ if (otherliveins == NULL) {
+ otherliveins = BB_live_in(succ);
+ } else {
+ otherliveins = GTN_SET_Union (otherliveins,
+ BB_live_in (succ), &merge_counter_pool);
+ }
+ }
+ }
+ }
+
+ fix_base_instructions (Cur_PU_Name, loop, otherliveins);
+
+ MEM_POOL_Pop(&merge_counter_pool);
+ }
+
+ MEM_POOL_Pop (&loop_descr_pool);
+ MEM_POOL_Delete(&loop_descr_pool);
+ Free_Dominators_Memory ();
+}
+
static OP *
Compose_Mem_Op( OP* op, TN* index, TN* offset, TN* scale, TN* base )
{
Modified: trunk/osprey/common/targ_info/isa/x8664/isa.cxx
===================================================================
--- trunk/osprey/common/targ_info/isa/x8664/isa.cxx 2011-04-16 09:01:45 UTC
(rev 3556)
+++ trunk/osprey/common/targ_info/isa/x8664/isa.cxx 2011-04-18 18:42:38 UTC
(rev 3557)
@@ -871,6 +871,8 @@
"ldapdx",
"ldapdxx",
"ldups",
+ "ldupsx",
+ "ldupsxx",
"ldupd",
"ldupdx",
"ldupdxx",
Modified: trunk/osprey/common/targ_info/isa/x8664/isa_operands.cxx
===================================================================
--- trunk/osprey/common/targ_info/isa/x8664/isa_operands.cxx 2011-04-16
09:01:45 UTC (rev 3556)
+++ trunk/osprey/common/targ_info/isa/x8664/isa_operands.cxx 2011-04-18
18:42:38 UTC (rev 3557)
@@ -5144,6 +5144,7 @@
TOP_ldupdx,
TOP_ldapdx,
TOP_ldapsx,
+ TOP_ldupsx,
TOP_fmovsldupxx,
TOP_fmovshdupxx,
TOP_fmovddupxx,
@@ -5212,6 +5213,7 @@
TOP_ldupdxx,
TOP_ldapdxx,
TOP_ldapsxx,
+ TOP_ldupsxx,
TOP_fmovsldupxxx,
TOP_fmovshdupxxx,
TOP_fmovddupxxx,
Modified: trunk/osprey/common/targ_info/isa/x8664/isa_pack.cxx
===================================================================
--- trunk/osprey/common/targ_info/isa/x8664/isa_pack.cxx 2011-04-16
09:01:45 UTC (rev 3556)
+++ trunk/osprey/common/targ_info/isa/x8664/isa_pack.cxx 2011-04-18
18:42:38 UTC (rev 3557)
@@ -771,6 +771,8 @@
TOP_ldaps, 0x000000ff,
TOP_ldupd, 0x000000ff,
TOP_ldups, 0x000000ff,
+ TOP_ldupsx, 0x000000ff,
+ TOP_ldupsxx, 0x000000ff,
TOP_stapd, 0x000000ff,
TOP_staps, 0x000000ff,
TOP_stupd, 0x000000ff,
Modified: trunk/osprey/common/targ_info/isa/x8664/isa_print.cxx
===================================================================
--- trunk/osprey/common/targ_info/isa/x8664/isa_print.cxx 2011-04-16
09:01:45 UTC (rev 3556)
+++ trunk/osprey/common/targ_info/isa/x8664/isa_print.cxx 2011-04-18
18:42:38 UTC (rev 3557)
@@ -3603,6 +3603,7 @@
TOP_ldx32_64,
TOP_ldapdx,
TOP_ldapsx,
+ TOP_ldupsx,
TOP_fmovsldupxx,
TOP_fmovshdupxx,
TOP_fmovddupxx,
@@ -3658,6 +3659,7 @@
TOP_ldhpdxx,
TOP_ldxx32_64,
TOP_ldapdxx,
+ TOP_ldupsxx,
TOP_ldapsxx,
TOP_fmovsldupxxx,
TOP_fmovshdupxxx,
Modified: trunk/osprey/common/targ_info/isa/x8664/isa_properties.cxx
===================================================================
--- trunk/osprey/common/targ_info/isa/x8664/isa_properties.cxx 2011-04-16
09:01:45 UTC (rev 3556)
+++ trunk/osprey/common/targ_info/isa/x8664/isa_properties.cxx 2011-04-18
18:42:38 UTC (rev 3557)
@@ -849,6 +849,8 @@
TOP_ldupdxx,
TOP_ldupd_n32,
TOP_ldups,
+ TOP_ldupsx,
+ TOP_ldupsxx,
TOP_ldups_n32,
TOP_lddqax,
TOP_lddqux,
@@ -3443,6 +3445,8 @@
TOP_ldupdx,
TOP_ldupdxx,
TOP_ldups,
+ TOP_ldupsx,
+ TOP_ldupsxx,
/* AVX instructions */
TOP_vlddqu_n32,
TOP_vlddqu,
@@ -3998,6 +4002,8 @@
TOP_ldupdxx,
TOP_ldupd_n32,
TOP_ldups,
+ TOP_ldupsx,
+ TOP_ldupsxx,
TOP_ldups_n32,
TOP_stdqu,
TOP_stdqu_n32,
@@ -5891,6 +5897,8 @@
TOP_ldupdxx,
TOP_ldupd_n32,
TOP_ldups,
+ TOP_ldupsx,
+ TOP_ldupsxx,
TOP_ldups_n32,
TOP_ld64_2sse,
TOP_ld64_2sse_n32,
@@ -9523,6 +9531,8 @@
TOP_ldapsx,
TOP_ldapsxx,
TOP_ldups,
+ TOP_ldupsx,
+ TOP_ldupsxx,
TOP_ldups_n32,
TOP_ldlps,
TOP_ldlps_n32,
Modified: trunk/osprey/common/targ_info/isa/x8664/isa_subset.cxx
===================================================================
--- trunk/osprey/common/targ_info/isa/x8664/isa_subset.cxx 2011-04-16
09:01:45 UTC (rev 3556)
+++ trunk/osprey/common/targ_info/isa/x8664/isa_subset.cxx 2011-04-18
18:42:38 UTC (rev 3557)
@@ -737,6 +737,8 @@
TOP_ldupdxx,
TOP_ldupd_n32,
TOP_ldups,
+ TOP_ldupsx,
+ TOP_ldupsxx,
TOP_ldups_n32,
TOP_stdqu,
TOP_stdqu_n32,
Modified: trunk/osprey/common/targ_info/proc/x8664/barcelona_si.cxx
===================================================================
--- trunk/osprey/common/targ_info/proc/x8664/barcelona_si.cxx 2011-04-16
09:01:45 UTC (rev 3556)
+++ trunk/osprey/common/targ_info/proc/x8664/barcelona_si.cxx 2011-04-18
18:42:38 UTC (rev 3557)
@@ -758,6 +758,8 @@
TOP_ldupdxx,
TOP_ldupd_n32,
TOP_ldups,
+ TOP_ldupsx,
+ TOP_ldupsxx,
TOP_ldups_n32,
TOP_ldmxcsr,
TOP_UNDEFINED );
Modified: trunk/osprey/common/targ_info/proc/x8664/core_si.cxx
===================================================================
--- trunk/osprey/common/targ_info/proc/x8664/core_si.cxx 2011-04-16
09:01:45 UTC (rev 3556)
+++ trunk/osprey/common/targ_info/proc/x8664/core_si.cxx 2011-04-18
18:42:38 UTC (rev 3557)
@@ -758,6 +758,8 @@
TOP_ldupdxx,
TOP_ldupd_n32,
TOP_ldups,
+ TOP_ldupsx,
+ TOP_ldupsxx,
TOP_ldups_n32,
TOP_ldmxcsr,
TOP_UNDEFINED );
Modified: trunk/osprey/common/targ_info/proc/x8664/em64t_si.cxx
===================================================================
--- trunk/osprey/common/targ_info/proc/x8664/em64t_si.cxx 2011-04-16
09:01:45 UTC (rev 3556)
+++ trunk/osprey/common/targ_info/proc/x8664/em64t_si.cxx 2011-04-18
18:42:38 UTC (rev 3557)
@@ -751,6 +751,8 @@
TOP_ldupdxx,
TOP_ldupd_n32,
TOP_ldups,
+ TOP_ldupsx,
+ TOP_ldupsxx,
TOP_ldups_n32,
TOP_ldmxcsr,
TOP_UNDEFINED );
Modified: trunk/osprey/common/targ_info/proc/x8664/opteron_si.cxx
===================================================================
--- trunk/osprey/common/targ_info/proc/x8664/opteron_si.cxx 2011-04-16
09:01:45 UTC (rev 3556)
+++ trunk/osprey/common/targ_info/proc/x8664/opteron_si.cxx 2011-04-18
18:42:38 UTC (rev 3557)
@@ -758,6 +758,8 @@
TOP_ldupdxx,
TOP_ldupd_n32,
TOP_ldups,
+ TOP_ldupsx,
+ TOP_ldupsxx,
TOP_ldups_n32,
TOP_ldmxcsr,
TOP_UNDEFINED );
Modified: trunk/osprey/common/targ_info/proc/x8664/orochi_si.cxx
===================================================================
--- trunk/osprey/common/targ_info/proc/x8664/orochi_si.cxx 2011-04-16
09:01:45 UTC (rev 3556)
+++ trunk/osprey/common/targ_info/proc/x8664/orochi_si.cxx 2011-04-18
18:42:38 UTC (rev 3557)
@@ -782,6 +782,8 @@
TOP_ldupdxx,
TOP_ldupd_n32,
TOP_ldups,
+ TOP_ldupsx,
+ TOP_ldupsxx,
TOP_ldups_n32,
TOP_ldmxcsr,
TOP_UNDEFINED );
Modified: trunk/osprey/common/targ_info/proc/x8664/wolfdale_si.cxx
===================================================================
--- trunk/osprey/common/targ_info/proc/x8664/wolfdale_si.cxx 2011-04-16
09:01:45 UTC (rev 3556)
+++ trunk/osprey/common/targ_info/proc/x8664/wolfdale_si.cxx 2011-04-18
18:42:38 UTC (rev 3557)
@@ -758,6 +758,8 @@
TOP_ldupdxx,
TOP_ldupd_n32,
TOP_ldups,
+ TOP_ldupsx,
+ TOP_ldupsxx,
TOP_ldups_n32,
TOP_ldmxcsr,
TOP_UNDEFINED );
------------------------------------------------------------------------------
Benefiting from Server Virtualization: Beyond Initial Workload
Consolidation -- Increasing the use of server virtualization is a top
priority.Virtualization can reduce costs, simplify management, and improve
application availability and disaster protection. Learn more about boosting
the value of server virtualization. http://p.sf.net/sfu/vmware-sfdev2dev
_______________________________________________
Open64-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/open64-devel
