> I am confused. It seems you attached some kind of reduced version of
> btCollisionWorld.cpp? How did you obtain it? Did you compile and test
> with these versions?
I’ve manually selected parts of code, which produce the scope.
I’ve found out that this bug is most probably caused by absence of
pointer handling. The tree, which is corresponding to P_11 has
pointer type. Furthermore, if we consider the transformed gimple code
for (it can be found attached), we’ll see that it contains wrong
parts:
The code produced by modified version of Graphite:
...
_35 = (signed long) _11;
_36 = _34 + _35;
_37 = _36 % 0;
_38 = _37 > 0;
_39 = (signed long) _38;
...
The code produced by origin version of Graphite:
...
_36 = (sizetype) _11;
_37 = _36 + 18446744073709551615;
_38 = 8B + _37;
_39 = _38 % 0B;
_40 = _39 != -1B;
...
(If I’m not mistaken, 0B, for example, corresponds to (void *). It
can be seen here: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=50712)
I’ve tried to implement pointer handling in the attached patch, but it
is wrong. I get the following error instead of seagfault now:
Floating point exception (core dumped)
back trace:
Program terminated with signal 8, Arithmetic exception.
#0 0x00000000004204c5 in allocSize (this=<optimized out>,
size=<optimized out>)
at
/home/roman/llvm-test-suite/MultiSource/Benchmarks/Bullet/include/LinearMath/btAlignedObjectArray.h:59
59 return (size ? size*2 : 1);
(gdb) bt
#0 0x00000000004204c5 in allocSize (this=<optimized out>,
size=<optimized out>)
at
/home/roman/llvm-test-suite/MultiSource/Benchmarks/Bullet/include/LinearMath/btAlignedObjectArray.h:59
#1 push_back (_Val=<synthetic pointer>, this=0x1125600)
at
/home/roman/llvm-test-suite/MultiSource/Benchmarks/Bullet/include/LinearMath/btAlignedObjectArray.h:220
#2 btCollisionDispatcher::getNewManifold (this=0x11255f0, b0=<optimized out>,
b1=<optimized out>) at btCollisionDispatcher.llvm.cpp:100
#3 0x000000000044e764 in
btConvexPlaneCollisionAlgorithm::btConvexPlaneCollisionAlgorithm
(this=0x7f665ca6b0c0, mf=0x0, ci=..., col0=<optimized out>,
col1=<optimized out>, isSwapped=<optimized out>,
numPerturbationIterations=1, minimumPointsPerturbationThreshold=1)
at
/home/roman/llvm-test-suite/MultiSource/Benchmarks/Bullet/btConvexPlaneCollisionAlgorithm.cpp:38
#4 0x000000000046281b in
btConvexPlaneCollisionAlgorithm::CreateFunc::CreateCollisionAlgorithm
(this=0x11254e0, ci=..., body0=0x113d040, body1=0x113d810)
at
/home/roman/llvm-test-suite/MultiSource/Benchmarks/Bullet/include/BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.h:76
#5 0x00000000004205ac in btCollisionDispatcher::findAlgorithm (
this=<optimized out>, body0=<optimized out>, body1=<optimized out>,
sharedManifold=<optimized out>) at btCollisionDispatcher.llvm.cpp:145
#6 0x00000000004202e2 in btCollisionDispatcher::defaultNearCallback (
---Type <return> to continue, or q <return> to quit---
collisionPair=..., dispatcher=..., dispatchInfo=...)
at btCollisionDispatcher.llvm.cpp:258
#7 0x000000000042083b in btCollisionPairCallback::processOverlap (
this=<optimized out>, pair=...) at btCollisionDispatcher.llvm.cpp:224
#8 0x00000000004acff2 in
btHashedOverlappingPairCache::processAllOverlappingPairs
(this=0x1127f80, callback=0x7fff0d1af790, dispatcher=0x11255f0)
at
/home/roman/llvm-test-suite/MultiSource/Benchmarks/Bullet/btOverlappingPairCache.cpp:387
#9 0x00000000004200c9 in btCollisionDispatcher::dispatchAllCollisionPairs (
this=<optimized out>, pairCache=<optimized out>, dispatchInfo=...,
dispatcher=<optimized out>) at btCollisionDispatcher.llvm.cpp:238
#10 0x0000000000421bd4 in btCollisionWorld::performDiscreteCollisionDetection()
()
#11 0x0000000000464d9a in
btDiscreteDynamicsWorld::internalSingleStepSimulation(float) ()
#12 0x000000000046473f in
btDiscreteDynamicsWorld::stepSimulation(float, int, float) ()
#13 0x0000000000401e08 in BenchmarkDemo::clientMoveAndDisplay (
this=0x7fff0d1af980)
at
/home/roman/llvm-test-suite/MultiSource/Benchmarks/Bullet/BenchmarkDemo.cpp:232
#14 0x0000000000401b12 in main (argc=<optimized out>, argv=<optimized out>)
at /home/roman/llvm-test-suite/MultiSource/Benchmarks/Bullet/main.cpp:63
Could you please advise me an algorithm for pointer handling?
--
Cheers, Roman Gareev.
loop_0 (header = 0, latch = 1, niter = )
{
bb_2 (preds = {bb_0 }, succs = {bb_4 bb_3 })
{
<bb 2>:
# DEBUG D#5 => &this_1(D)->m_manifoldsPtr
# DEBUG this => D#5
# VUSE <.MEM_3(D)>
_5 = MEM[(struct btAlignedObjectArray *)this_1(D) + 8B].m_size;
_6 = _5 * 2;
# DEBUG D#4 => &D#5->m_allocator
# DEBUG D#2 => D#4
# DEBUG D#3 => 0B
# DEBUG n => _6
# DEBUG this => D#2
# DEBUG hint => D#3
_7 = (long unsigned int) _6;
_8 = (unsigned int) _7;
_9 = _8 * 8;
_10 = (int) _9;
# .MEM_22 = VDEF <.MEM_3(D)>
_11 = btAlignedAlloc (_10, 16);
# DEBUG s => _11
# DEBUG i => 0
# DEBUG i => 0
# VUSE <.MEM_22>
_2 = MEM[(struct btAlignedObjectArray *)this_1(D) + 8B].m_size;
if (_2 > 0)
goto <bb 4>;
else
goto <bb 3>;
}
bb_3 (preds = {bb_2 bb_10 }, succs = {bb_11 })
{
<bb 3>:
# .MEM_21 = PHI <.MEM_22(2), .MEM_24(10)>
}
bb_11 (preds = {bb_3 }, succs = {bb_1 })
{
<bb 11>:
# VUSE <.MEM_21>
return;
}
bb_4 (preds = {bb_2 }, succs = {bb_14 })
{
<bb 4>:
}
bb_14 (preds = {bb_4 }, succs = {bb_18 bb_5 })
{
<bb 14>:
if (0 != 0)
goto <bb 18>;
else
goto <bb 5>;
}
bb_18 (preds = {bb_14 }, succs = {bb_22 bb_21 })
{
<bb 18>:
_20 = -_11;
_30 = _20 + 9;
_31 = _30 <= 8B;
if (_31 != 0)
goto <bb 22>;
else
goto <bb 21>;
}
bb_21 (preds = {bb_18 }, succs = {bb_19 })
{
<bb 21>:
goto <bb 19>;
}
bb_22 (preds = {bb_18 }, succs = {bb_28 bb_25 })
{
<bb 22>:
_32 = _2 > 0;
if (_32 != 0)
goto <bb 28>;
else
goto <bb 25>;
}
bb_25 (preds = {bb_22 }, succs = {bb_23 })
{
<bb 25>:
goto <bb 23>;
}
bb_28 (preds = {bb_22 }, succs = {bb_26 })
{
<bb 28>:
_33 = _2 + -1;
}
bb_30 (preds = {bb_29 }, succs = {bb_24 })
{
<bb 30>:
}
bb_24 (preds = {bb_30 }, succs = {bb_23 })
{
<bb 24>:
}
bb_23 (preds = {bb_24 bb_25 }, succs = {bb_20 })
{
<bb 23>:
# .MEM_51 = PHI <.MEM_53(24), .MEM_22(25)>
}
bb_20 (preds = {bb_23 }, succs = {bb_19 })
{
<bb 20>:
}
bb_19 (preds = {bb_20 bb_21 }, succs = {bb_16 })
{
<bb 19>:
# .MEM_50 = PHI <.MEM_51(20), .MEM_22(21)>
}
bb_16 (preds = {bb_19 }, succs = {bb_15 })
{
<bb 16>:
}
bb_15 (preds = {bb_16 bb_8 }, succs = {bb_13 })
{
<bb 15>:
# .MEM_24 = PHI <.MEM_50(16), .MEM_12(8)>
}
bb_13 (preds = {bb_15 }, succs = {bb_12 })
{
<bb 13>:
goto <bb 12>;
}
bb_8 (preds = {bb_7 }, succs = {bb_15 })
{
<bb 8>:
# .MEM_12 = PHI <.MEM_4(7)>
goto <bb 15>;
}
bb_12 (preds = {bb_13 }, succs = {bb_10 })
{
<bb 12>:
}
bb_10 (preds = {bb_12 }, succs = {bb_3 })
{
<bb 10>:
goto <bb 3>;
}
loop_2 (header = 26, latch = 27, niter = )
{
bb_26 (preds = {bb_28 bb_27 }, succs = {bb_31 })
{
<bb 26>:
# graphite_IV.7_34 = PHI <0(28), graphite_IV.7_35(27)>
# .MEM_52 = PHI <.MEM_22(28), .MEM_53(27)>
}
bb_31 (preds = {bb_26 }, succs = {bb_35 bb_34 })
{
<bb 31>:
_36 = (sizetype) _11;
_37 = _36 + 18446744073709551615;
_38 = 8B + _37;
_39 = _38 % 0B;
_40 = _39 != -1B;
if (_40 != 0)
goto <bb 35>;
else
goto <bb 34>;
}
bb_34 (preds = {bb_31 }, succs = {bb_32 })
{
<bb 34>:
goto <bb 32>;
}
bb_35 (preds = {bb_31 }, succs = {bb_33 })
{
<bb 35>:
# VUSE <.MEM_52>
_41 = MEM[(struct btAlignedObjectArray *)this_1(D) + 8B].m_data;
_43 = (long unsigned int) graphite_IV.7_34;
_44 = _43 * 8;
_42 = _41 + _44;
# VUSE <.MEM_52>
_45 = *_42;
_47 = (sizetype) graphite_IV.7_34;
_48 = _47 * 8;
_49 = _11 + _48;
# .MEM_46 = VDEF <.MEM_52>
MEM[(struct btCollisionDispatcher * *)_49] = _45;
}
bb_33 (preds = {bb_35 }, succs = {bb_32 })
{
<bb 33>:
}
bb_32 (preds = {bb_33 bb_34 }, succs = {bb_29 })
{
<bb 32>:
# .MEM_53 = PHI <.MEM_46(33), .MEM_52(34)>
}
bb_29 (preds = {bb_32 }, succs = {bb_27 bb_30 })
{
<bb 29>:
graphite_IV.7_35 = graphite_IV.7_34 + 1;
if (graphite_IV.7_34 < _33)
goto <bb 27>;
else
goto <bb 30>;
}
bb_27 (preds = {bb_29 }, succs = {bb_26 })
{
<bb 27>:
goto <bb 26>;
}
}
loop_1 (header = 5, latch = 9, niter = , upper_bound = 2147483646)
{
bb_5 (preds = {bb_14 bb_9 }, succs = {bb_6 bb_7 })
{
<bb 5>:
# i_26 = PHI <0(14), i_19(9)>
# .MEM_27 = PHI <.MEM_22(14), .MEM_4(9)>
# DEBUG i => i_26
_13 = (long unsigned int) i_26;
_14 = _13 * 8;
_15 = _11 + _14;
# DEBUG D#1 => 8
# DEBUG __p => _15
# DEBUG D.2562 => D#1
if (_15 != 0B)
goto <bb 6>;
else
goto <bb 7>;
}
bb_6 (preds = {bb_5 }, succs = {bb_7 })
{
<bb 6>:
# VUSE <.MEM_27>
_16 = MEM[(struct btAlignedObjectArray *)this_1(D) + 8B].m_data;
_17 = _16 + _14;
# VUSE <.MEM_27>
_18 = *_17;
# .MEM_23 = VDEF <.MEM_27>
MEM[(struct btCollisionDispatcher * *)_15] = _18;
}
bb_7 (preds = {bb_5 bb_6 }, succs = {bb_9 bb_8 })
{
<bb 7>:
# .MEM_4 = PHI <.MEM_27(5), .MEM_23(6)>
i_19 = i_26 + 1;
# DEBUG i => i_19
# DEBUG i => i_19
if (_2 > i_19)
goto <bb 9>;
else
goto <bb 8>;
}
bb_9 (preds = {bb_7 }, succs = {bb_5 })
{
<bb 9>:
goto <bb 5>;
}
}
}loop_0 (header = 0, latch = 1, niter = )
{
bb_2 (preds = {bb_0 }, succs = {bb_4 bb_3 })
{
<bb 2>:
# DEBUG D#5 => &this_1(D)->m_manifoldsPtr
# DEBUG this => D#5
# VUSE <.MEM_3(D)>
_5 = MEM[(struct btAlignedObjectArray *)this_1(D) + 8B].m_size;
_6 = _5 * 2;
# DEBUG D#4 => &D#5->m_allocator
# DEBUG D#2 => D#4
# DEBUG D#3 => 0B
# DEBUG n => _6
# DEBUG this => D#2
# DEBUG hint => D#3
_7 = (long unsigned int) _6;
_8 = (unsigned int) _7;
_9 = _8 * 8;
_10 = (int) _9;
# .MEM_22 = VDEF <.MEM_3(D)>
_11 = btAlignedAlloc (_10, 16);
# DEBUG s => _11
# DEBUG i => 0
# DEBUG i => 0
# VUSE <.MEM_22>
_2 = MEM[(struct btAlignedObjectArray *)this_1(D) + 8B].m_size;
if (_2 > 0)
goto <bb 4>;
else
goto <bb 3>;
}
bb_3 (preds = {bb_2 bb_10 }, succs = {bb_1 })
{
<bb 3>:
# .MEM_21 = PHI <.MEM_22(2), .MEM_49(10)>
# VUSE <.MEM_21>
return;
}
bb_4 (preds = {bb_2 }, succs = {bb_5 bb_10 })
{
<bb 4>:
_20 = _2 > 0;
if (_20 != 0)
goto <bb 5>;
else
goto <bb 10>;
}
bb_5 (preds = {bb_4 }, succs = {bb_6 })
{
<bb 5>:
_30 = (signed long) _2;
_31 = _30 + -1;
}
bb_10 (preds = {bb_8 bb_4 }, succs = {bb_3 })
{
<bb 10>:
# .MEM_49 = PHI <.MEM_51(8), .MEM_22(4)>
goto <bb 3>;
}
loop_2 (header = 6, latch = 9, niter = (unsigned long) ((signed long) _2 +
-1), upper_bound = 1152921504606846975)
{
bb_6 (preds = {bb_5 bb_9 }, succs = {bb_7 bb_8 })
{
<bb 6>:
# graphite_IV.7_32 = PHI <0(5), graphite_IV.7_33(9)>
# .MEM_50 = PHI <.MEM_22(5), .MEM_51(9)>
_34 = graphite_IV.7_32 * 8;
_35 = (signed long) _11;
_36 = _34 + _35;
_37 = _36 % 0;
_38 = _37 > 0;
_39 = (signed long) _38;
if (_39 != 0)
goto <bb 7>;
else
goto <bb 8>;
}
bb_7 (preds = {bb_6 }, succs = {bb_8 })
{
<bb 7>:
# VUSE <.MEM_50>
_40 = MEM[(struct btAlignedObjectArray *)this_1(D) + 8B].m_data;
_42 = (long unsigned int) graphite_IV.7_32;
_43 = _42 * 8;
_41 = _40 + _43;
# VUSE <.MEM_50>
_44 = *_41;
_46 = (sizetype) graphite_IV.7_32;
_47 = _46 * 8;
_48 = _11 + _47;
# .MEM_45 = VDEF <.MEM_50>
MEM[(struct btCollisionDispatcher * *)_48] = _44;
}
bb_8 (preds = {bb_7 bb_6 }, succs = {bb_9 bb_10 })
{
<bb 8>:
# .MEM_51 = PHI <.MEM_45(7), .MEM_50(6)>
graphite_IV.7_33 = graphite_IV.7_32 + 1;
if (graphite_IV.7_32 < _31)
goto <bb 9>;
else
goto <bb 10>;
}
bb_9 (preds = {bb_8 }, succs = {bb_6 })
{
<bb 9>:
goto <bb 6>;
}
}
}Index: gcc/graphite-isl-ast-to-gimple.c
===================================================================
--- gcc/graphite-isl-ast-to-gimple.c (revision 213774)
+++ gcc/graphite-isl-ast-to-gimple.c (working copy)
@@ -150,6 +150,8 @@
gcc_assert (res != ip.end () &&
"Could not map isl_id to tree expression");
isl_ast_expr_free (expr_id);
+ if (POINTER_TYPE_P (TREE_TYPE (res->second)))
+ return res->second;
return fold_convert (type, res->second);
}
@@ -178,18 +180,46 @@
type TYPE. */
static tree
-binary_op_to_tree (tree type, __isl_take isl_ast_expr *expr, ivs_params &ip)
+binary_op_to_tree (tree recommended_type, __isl_take isl_ast_expr *expr,
+ ivs_params &ip)
{
isl_ast_expr *arg_expr = isl_ast_expr_get_op_arg (expr, 0);
- tree tree_lhs_expr = gcc_expression_from_isl_expression (type, arg_expr, ip);
+ tree tree_lhs_expr =
+ gcc_expression_from_isl_expression (recommended_type, arg_expr, ip);
arg_expr = isl_ast_expr_get_op_arg (expr, 1);
- tree tree_rhs_expr = gcc_expression_from_isl_expression (type, arg_expr, ip);
+ tree tree_rhs_expr =
+ gcc_expression_from_isl_expression (recommended_type, arg_expr, ip);
+ tree type = POINTER_TYPE_P (TREE_TYPE (tree_lhs_expr)) ?
+ TREE_TYPE (tree_lhs_expr) : recommended_type;
+ type = POINTER_TYPE_P (TREE_TYPE (tree_rhs_expr)) ?
+ TREE_TYPE (tree_rhs_expr) : type;
+ if (POINTER_TYPE_P (type))
+ {
+ if (isl_ast_expr_get_op_type (expr) == isl_ast_op_add ||
+ isl_ast_expr_get_op_type (expr) == isl_ast_op_mul ||
+ isl_ast_expr_get_op_type (expr) == isl_ast_op_div)
+ {
+ if (!POINTER_TYPE_P (TREE_TYPE (tree_lhs_expr)))
+ tree_lhs_expr = fold_convert (sizetype, tree_lhs_expr);
+ if (!POINTER_TYPE_P (TREE_TYPE (tree_rhs_expr)))
+ tree_rhs_expr = fold_convert (sizetype, tree_rhs_expr);
+ }
+ else
+ {
+ tree_lhs_expr = fold_convert (type, tree_lhs_expr);
+ tree_rhs_expr = fold_convert (type, tree_rhs_expr);
+ }
+ }
enum isl_ast_op_type expr_type = isl_ast_expr_get_op_type (expr);
isl_ast_expr_free (expr);
switch (expr_type)
{
case isl_ast_op_add:
- return fold_build2 (PLUS_EXPR, type, tree_lhs_expr, tree_rhs_expr);
+ if (POINTER_TYPE_P (type))
+ return fold_build2 (POINTER_PLUS_EXPR, type, tree_lhs_expr,
+ tree_rhs_expr);
+ else
+ return fold_build2 (PLUS_EXPR, type, tree_lhs_expr, tree_rhs_expr);
case isl_ast_op_sub:
return fold_build2 (MINUS_EXPR, type, tree_lhs_expr, tree_rhs_expr);
@@ -210,26 +240,32 @@
return fold_build2 (FLOOR_DIV_EXPR, type, tree_lhs_expr, tree_rhs_expr);
case isl_ast_op_and:
- return fold_build2 (TRUTH_ANDIF_EXPR, type,
+ return fold_build2 (TRUTH_ANDIF_EXPR, boolean_type_node,
tree_lhs_expr, tree_rhs_expr);
case isl_ast_op_or:
- return fold_build2 (TRUTH_ORIF_EXPR, type, tree_lhs_expr, tree_rhs_expr);
+ return fold_build2 (TRUTH_ORIF_EXPR, boolean_type_node, tree_lhs_expr,
+ tree_rhs_expr);
case isl_ast_op_eq:
- return fold_build2 (EQ_EXPR, type, tree_lhs_expr, tree_rhs_expr);
+ return fold_build2 (EQ_EXPR, boolean_type_node, tree_lhs_expr,
+ tree_rhs_expr);
case isl_ast_op_le:
- return fold_build2 (LE_EXPR, type, tree_lhs_expr, tree_rhs_expr);
+ return fold_build2 (LE_EXPR, boolean_type_node, tree_lhs_expr,
+ tree_rhs_expr);
case isl_ast_op_lt:
- return fold_build2 (LT_EXPR, type, tree_lhs_expr, tree_rhs_expr);
+ return fold_build2 (LT_EXPR, boolean_type_node, tree_lhs_expr,
+ tree_rhs_expr);
case isl_ast_op_ge:
- return fold_build2 (GE_EXPR, type, tree_lhs_expr, tree_rhs_expr);
+ return fold_build2 (GE_EXPR, boolean_type_node, tree_lhs_expr,
+ tree_rhs_expr);
case isl_ast_op_gt:
- return fold_build2 (GT_EXPR, type, tree_lhs_expr, tree_rhs_expr);
+ return fold_build2 (GT_EXPR, boolean_type_node, tree_lhs_expr,
+ tree_rhs_expr);
default:
gcc_unreachable ();
@@ -261,12 +297,16 @@
type TYPE. */
static tree
-unary_op_to_tree (tree type, __isl_take isl_ast_expr *expr, ivs_params &ip)
+unary_op_to_tree (tree recommended_type, __isl_take isl_ast_expr *expr,
+ ivs_params &ip)
{
gcc_assert (isl_ast_expr_get_op_type (expr) == isl_ast_op_minus);
isl_ast_expr *arg_expr = isl_ast_expr_get_op_arg (expr, 0);
- tree tree_expr = gcc_expression_from_isl_expression (type, arg_expr, ip);
+ tree tree_expr =
+ gcc_expression_from_isl_expression (recommended_type, arg_expr, ip);
isl_ast_expr_free (expr);
+ tree type = POINTER_TYPE_P (TREE_TYPE (tree_expr)) ?
+ TREE_TYPE (tree_expr) : recommended_type;
return fold_build1 (NEGATE_EXPR, type, tree_expr);
}
