Author: meiye
Date: 2011-05-23 13:18:57 -0400 (Mon, 23 May 2011)
New Revision: 3616
Modified:
trunk/osprey/be/opt/opt_proactive.cxx
trunk/osprey/be/opt/opt_wn.cxx
trunk/osprey/be/opt/opt_wn.h
Log:
Change interface of 'WN_get_val' to use std::pair to return two values. CR:
Sun Chan
Modified: trunk/osprey/be/opt/opt_proactive.cxx
===================================================================
--- trunk/osprey/be/opt/opt_proactive.cxx 2011-05-23 17:14:34 UTC (rev
3615)
+++ trunk/osprey/be/opt/opt_proactive.cxx 2011-05-23 17:18:57 UTC (rev
3616)
@@ -11571,9 +11571,13 @@
WN * wn_tmp = (WN *) WN_MAP_Get(map, wn_key);
int val_tmp;
- if (wn_tmp && WN_get_val(wn_key, &val_tmp, map)
- && (val_tmp < val))
- return;
+ if (wn_tmp) {
+ std::pair<bool,int> p_val = WN_get_val(wn_key, map);
+ val_tmp = p_val.second;
+ if (p_val.first
+ && (val_tmp < val))
+ return;
+ }
Set_map(map, wn_key, Get_const_wn(val));
}
@@ -11620,13 +11624,16 @@
WN * wn_tmp;
int val;
int val2;
+ std::pair<bool,int> p_val;
switch (opr) {
case OPR_GT:
op1 = WN_kid(wn, 0);
op2 = WN_kid(wn, 1);
+ p_val = WN_get_val(op2, _low_map);
+ val = p_val.second;
- if (WN_get_val(op2, &val, _low_map)) {
+ if (p_val.first) {
Set_map(_low_map, op1, op2);
Infer_val_range(op1, TRUE, TRUE);
}
@@ -11636,8 +11643,10 @@
case OPR_LT:
op1 = WN_kid(wn, 0);
op2 = WN_kid(wn, 1);
-
- if (WN_get_val(op1, &val, _low_map)) {
+ p_val = WN_get_val(op1, _low_map);
+ val = p_val.second;
+
+ if (p_val.first) {
Set_map(_low_map, op2, op1);
Infer_val_range(op2, TRUE, TRUE);
}
@@ -11646,8 +11655,10 @@
case OPR_LE:
op1 = WN_kid(wn, 0);
op2 = WN_kid(wn, 1);
+ p_val = WN_get_val(op1, _low_map);
+ val = p_val.second;
- if (WN_get_val(op1, &val, _low_map)) {
+ if (p_val.first) {
wn_tmp = Get_const_wn(val - 1);
Set_map(_low_map, op2, wn_tmp);
Infer_val_range(op2, TRUE, TRUE);
@@ -11661,23 +11672,30 @@
if (WN_operator(op2) == OPR_INTCONST) {
if (_low_map) {
wn_tmp = (WN *) WN_MAP_Get(_low_map, wn);
-
- if (wn_tmp && WN_get_val(wn_tmp, &val, _low_map)) {
- long long new_val = -1 * WN_const_val(op2) + val;
- wn_tmp = Get_const_wn(new_val);
- Set_map(_low_map, op1, wn_tmp);
- Infer_val_range(op1, TRUE, TRUE);
+ if (wn_tmp) {
+ p_val = WN_get_val(wn_tmp, _low_map);
+ val = p_val.second;
+ if (p_val.first) {
+ long long new_val = -1 * WN_const_val(op2) + val;
+ wn_tmp = Get_const_wn(new_val);
+ Set_map(_low_map, op1, wn_tmp);
+ Infer_val_range(op1, TRUE, TRUE);
+ }
}
}
if (_high_map) {
wn_tmp = (WN *) WN_MAP_Get(_high_map, wn);
- if (wn_tmp && WN_get_val(wn_tmp, &val, _high_map)) {
- long long new_val = -1 * WN_const_val(op2) + val;
- wn_tmp = Get_const_wn(new_val);
- Set_map(_high_map, op1, wn_tmp);
- Infer_val_range(op1, TRUE, TRUE);
+ if (wn_tmp) {
+ p_val = WN_get_val(wn_tmp, _high_map);
+ val = p_val.second;
+ if (p_val.first) {
+ long long new_val = -1 * WN_const_val(op2) + val;
+ wn_tmp = Get_const_wn(new_val);
+ Set_map(_high_map, op1, wn_tmp);
+ Infer_val_range(op1, TRUE, TRUE);
+ }
}
}
}
@@ -11692,14 +11710,22 @@
if (_low_map) {
wn_tmp = (WN * ) WN_MAP_Get(_low_map, wn);
- if (wn_tmp && WN_get_val(wn_tmp, &val, _low_map)) {
- wn_tmp = (WN *) WN_MAP_Get(_low_map, op2);
-
- if (wn_tmp && WN_get_val(op2, &val2, _low_map)) {
- long long new_val = val2 + val;
- wn_tmp = Get_const_wn(new_val);
- Set_map(_low_map, op1, wn_tmp);
- Infer_val_range(op1, TRUE, TRUE);
+ if (wn_tmp) {
+ p_val = WN_get_val(wn_tmp, _low_map);
+ val = p_val.second;
+ if (p_val.first) {
+ wn_tmp = (WN *) WN_MAP_Get(_low_map, op2);
+
+ if (wn_tmp) {
+ p_val = WN_get_val(op2, _low_map);
+ val2 = p_val.second;
+ if (p_val.first) {
+ long long new_val = val2 + val;
+ wn_tmp = Get_const_wn(new_val);
+ Set_map(_low_map, op1, wn_tmp);
+ Infer_val_range(op1, TRUE, TRUE);
+ }
+ }
}
}
}
@@ -11707,14 +11733,22 @@
if (_high_map) {
wn_tmp = (WN * ) WN_MAP_Get(_high_map, wn);
- if (wn_tmp && WN_get_val(wn_tmp, &val, _high_map)) {
- wn_tmp = (WN *) WN_MAP_Get(_high_map, op2);
+ if (wn_tmp) {
+ p_val = WN_get_val(wn_tmp, _high_map);
+ val = p_val.second;
+ if (p_val.first) {
+ wn_tmp = (WN *) WN_MAP_Get(_high_map, op2);
- if (wn_tmp && WN_get_val(op2, &val2, _high_map)) {
- long long new_val = val2 + val;
- wn_tmp = Get_const_wn(new_val);
- Set_map(_high_map, op1, wn_tmp);
- Infer_val_range(op1, TRUE, TRUE);
+ if (wn_tmp) {
+ p_val = WN_get_val(op2, _high_map);
+ val2 = p_val.second;
+ if (p_val.first) {
+ long long new_val = val2 + val;
+ wn_tmp = Get_const_wn(new_val);
+ Set_map(_high_map, op1, wn_tmp);
+ Infer_val_range(op1, TRUE, TRUE);
+ }
+ }
}
}
}
@@ -11812,8 +11846,10 @@
&& wn_load && OPERATOR_is_scalar_load(WN_operator(wn_load))
&& (WN_aux(wn_load) == WN_aux(wn_step))
&& (WN_operator(wn_add) == OPR_ADD)) {
- int val;
- if (WN_get_val(WN_kid(wn_add,1), &val, _low_map)) {
+ std::pair<bool, int> p_val = WN_get_val(WN_kid(wn_add,1),_low_map);
+ int val = p_val.second;
+
+ if (p_val.first) {
if (val > 0)
set_low = TRUE;
else
Modified: trunk/osprey/be/opt/opt_wn.cxx
===================================================================
--- trunk/osprey/be/opt/opt_wn.cxx 2011-05-23 17:14:34 UTC (rev 3615)
+++ trunk/osprey/be/opt/opt_wn.cxx 2011-05-23 17:18:57 UTC (rev 3616)
@@ -1792,42 +1792,51 @@
return OPERATOR_is_volatile(OPCODE_operator(opc));
}
-// Evaluate value of an integral WHIRL, return it in *val.
-// Return FALSE if wn is not evaluatable. wn_map gives a WHIRL-to-WHIRL
-// map that maps a WHIRL to another WHIRL containing the same value.
+// Given an integral WHIRL, query whether it is evaluatable and get the
evaluated value.
+// 'wn_map' gives a WHIRL-to-WHIRL map that maps a WHIRL to another WHIRL
containing the same value.
// (TODO: Implementation is incomplete for all operators)
-BOOL
-WN_get_val(WN * wn, int * val, const WN_MAP& wn_map)
+std::pair<bool,int>
+WN_get_val(WN * wn, const WN_MAP& wn_map)
{
- int val1, val2;
+ int val1, val2, val;
OPERATOR opr = WN_operator(wn);
WN * op1;
WN * op2;
if (opr == OPR_INTCONST) {
- *val = WN_const_val(wn);
- return TRUE;
+ val = WN_const_val(wn);
+ return std::pair<bool, int>(TRUE, val);
}
else if (wn_map) {
WN * wn_val = (WN *) WN_MAP_Get(wn_map, wn);
if (wn_val)
- return WN_get_val(wn_val, val, wn_map);
+ return WN_get_val(wn_val, wn_map);
}
+ std::pair<bool,int> pair1;
+ std::pair<bool,int> pair2;
switch (opr) {
case OPR_ADD:
- if (WN_get_val(WN_kid(wn,0), &val1, wn_map)
- && WN_get_val(WN_kid(wn, 1), &val2, wn_map)) {
- *val = val1 + val2;
- return TRUE;
+ pair1 = WN_get_val(WN_kid(wn, 0), wn_map);
+ pair2 = WN_get_val(WN_kid(wn, 1), wn_map);
+ val1 = pair1.second;
+ val2 = pair2.second;
+ if (pair1.first
+ && pair2.first) {
+ val = val1 + val2;
+ return std::pair<bool,int>(TRUE, val);
}
break;
case OPR_MPY:
op1 = WN_kid(wn, 0);
op2 = WN_kid(wn, 1);
-
- if (WN_get_val(op1, &val1, wn_map)
- && WN_get_val(op2, &val2, wn_map)
+ pair1 = WN_get_val(op1, wn_map);
+ pair2 = WN_get_val(op2, wn_map);
+ val1 = pair1.second;
+ val2 = pair2.second;
+
+ if (pair1.first
+ && pair2.first
&& (val1 > 0)
&& (val2 > 0)
&& ((WN_operator(op1) == OPR_INTCONST)
@@ -1836,15 +1845,15 @@
// Or "b >= c2", where c0, c1, c2 are constants.
// The inferred value can be incorrect if either "c0",
// "c1" or "c2" is non-positive.
- *val = val1 * val2;
- return TRUE;
+ val = val1 * val2;
+ return std::pair<bool,int>(TRUE, val);
}
break;
default:
;
}
- return FALSE;
+ return std::pair<bool,int>(FALSE,0);
}
// Walk nodes in the given WHIRL tree, collect operands for ADD operators.
@@ -1910,6 +1919,7 @@
OPERATOR opr1 = WN_operator(wn1);
OPERATOR opr2 = WN_operator(wn2);
int val;
+ std::pair<bool,int> p_val;
if ((opr1 == OPR_INTCONST) && (opr2 == OPR_INTCONST)) {
return (WN_const_val(wn1) != WN_const_val(wn2));
@@ -1924,11 +1934,16 @@
if (opr2 == OPR_INTCONST) {
int bit2 = WN_get_bit_from_const(wn2);
-
- if (WN_get_val(bit1, &val, lo_map) && (val > bit2))
+ p_val = WN_get_val(bit1, lo_map);
+ val = p_val.second;
+ if (p_val.first && (val > bit2))
return TRUE;
- else if (WN_get_val(bit1, &val, hi_map) && (val < bit2))
- return TRUE;
+ else {
+ p_val = WN_get_val(bit1, hi_map);
+ val = p_val.second;
+ if (p_val.first && (val < bit2))
+ return TRUE;
+ }
}
else {
WN * bit2 = WN_get_bit_from_expr(wn2);
@@ -1939,11 +1954,16 @@
}
else if ( opr2 == OPR_INTCONST) {
int int_val = WN_const_val(wn2);
-
- if (WN_get_val(wn1, &val, lo_map) && (val > int_val))
+ p_val = WN_get_val(wn1, lo_map);
+ val = p_val.second;
+ if (p_val.first && (val > int_val))
return TRUE;
- else if (WN_get_val(wn1, &val, hi_map) && (val < int_val))
- return TRUE;
+ else{
+ p_val = WN_get_val(wn1, hi_map);
+ val = p_val.second;
+ if (p_val.first && (val < int_val))
+ return TRUE;
+ }
}
else {
MEM_POOL * pool = Malloc_Mem_Pool;
@@ -1982,6 +2002,7 @@
int delta_lo = delta;
int delta_hi = delta;
+ std::pair<bool, int> p_val;
if (stack2) {
for (int i = 0; i < stack2->Elements(); i++) {
@@ -2004,15 +2025,21 @@
if (!found) {
int val;
+ p_val = WN_get_val(wn2_iter, lo_map);
+ val = p_val.second;
- if (WN_get_val(wn2_iter, &val, lo_map))
+ if (p_val.first)
delta_hi -= val;
- else if (WN_get_val(wn2_iter, &val, hi_map))
- delta_lo -= val;
else {
- CXX_DELETE(stack1, pool);
- CXX_DELETE(stack2, pool);
- return FALSE;
+ p_val = WN_get_val(wn2_iter, hi_map);
+ val = p_val.second;
+ if (p_val.first)
+ delta_lo -= val;
+ else {
+ CXX_DELETE(stack1, pool);
+ CXX_DELETE(stack2, pool);
+ return FALSE;
+ }
}
}
}
@@ -2025,16 +2052,22 @@
if (WN_operator(wn_iter) == OPR_INTCONST)
continue;
-
- if (WN_get_val(wn_iter, &val, lo_map))
+
+ p_val = WN_get_val(wn_iter, lo_map);
+ val = p_val.second;
+ if (p_val.first)
delta_lo += val;
- else if (WN_get_val(wn_iter, &val, hi_map))
- delta_hi += val;
else {
- CXX_DELETE(stack1, pool);
- if (stack2)
- CXX_DELETE(stack2, pool);
- return FALSE;
+ p_val = WN_get_val(wn_iter, hi_map);
+ val = p_val.second;
+ if (p_val.first)
+ delta_hi += val;
+ else {
+ CXX_DELETE(stack1, pool);
+ if (stack2)
+ CXX_DELETE(stack2, pool);
+ return FALSE;
+ }
}
}
}
Modified: trunk/osprey/be/opt/opt_wn.h
===================================================================
--- trunk/osprey/be/opt/opt_wn.h 2011-05-23 17:14:34 UTC (rev 3615)
+++ trunk/osprey/be/opt/opt_wn.h 2011-05-23 17:18:57 UTC (rev 3616)
@@ -349,7 +349,7 @@
extern BOOL OPCODE_is_fake(OPCODE opc);
extern BOOL OPERATOR_is_volatile(OPERATOR oper);
extern BOOL OPCODE_is_volatile(OPCODE opc);
-extern BOOL WN_get_val(WN *, int *, const WN_MAP&);
+extern std::pair<bool, int> WN_get_val(WN *, const WN_MAP&);
extern BOOL WN_has_disjoint_val_range(WN *, WN *, const WN_MAP&, const
WN_MAP&);
extern void Collect_operands(WN *, STACK<WN *> *, STACK<WN *> *);
------------------------------------------------------------------------------
What Every C/C++ and Fortran developer Should Know!
Read this article and learn how Intel has extended the reach of its
next-generation tools to help Windows* and Linux* C/C++ and Fortran
developers boost performance applications - including clusters.
http://p.sf.net/sfu/intel-dev2devmay
_______________________________________________
Open64-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/open64-devel
