GUFA: Infer using TrapsNeverHappen (#5850)

This adds a TrapsNeverHappen oracle that is used inside the main PossibleContents
oracle of GUFA. The idea is that when traps never happen we can reason "backwards"
from information to things that must be true before it:

temp = x.field;
x.cast_to<Y>(); // Y is a subtype of x's type X

Here we cast x to a subtype. If we assume traps never happen then the cast must
succeed, and that means we can assume we had a Y on the previous line, where
perhaps that information lets us infer the value of x.field.

This PR focuses on calls, which are the more interesting situation to optimize
because other passes do some work already inside functions. Specifically, we look
for things that will trap in the called function or the caller, such as if the called
function always casts a param to some type, we can assume the caller passes
such a type in. And if we have a call_ref then any target that would trap cannot be
called (at least in a closed world).

This has some benefits, in particular when combined with --gufa-cast-all since
that casts more things, which lets us apply the inferences made here. I see 3.3%
fewer call_ref instructions on a Kotlin testcase, for example. This helps more
on -Os when we inline less.

1 files changed, 5 insertions, 3 deletions

diff --git a/test/gtest/possible-contents.cpp b/test/gtest/possible-contents.cpp
index e10773550..1092a825b 100644
--- a/test/gtest/possible-contents.cpp
+++ b/test/gtest/possible-contents.cpp
@@ -263,6 +263,8 @@ TEST_F(PossibleContentsTest, TestCombinations) {
   assertCombination(anyGlobal, i31Null, coneAnyref);
 }
 
+static PassOptions options;
+
 TEST_F(PossibleContentsTest, TestOracleMinimal) {
   // A minimal test of the public API of PossibleTypesOracle. See the lit test
   // for coverage of all the internals (using lit makes the result more
@@ -273,7 +275,7 @@ TEST_F(PossibleContentsTest, TestOracleMinimal) {
       (global $something i32 (i32.const 42))
     )
   )");
-  ContentOracle oracle(*wasm);
+  ContentOracle oracle(*wasm, options);
 
   // This will be a null constant.
   EXPECT_TRUE(oracle.getContents(GlobalLocation{"null"}).isNull());
@@ -917,7 +919,7 @@ TEST_F(PossibleContentsTest, TestOracleManyTypes) {
       )
     )
   )");
-  ContentOracle oracle(*wasm);
+  ContentOracle oracle(*wasm, options);
   // The body's contents must be a cone of data with depth 1.
   auto bodyContents =
     oracle.getContents(ResultLocation{wasm->getFunction("foo"), 0});
@@ -943,7 +945,7 @@ TEST_F(PossibleContentsTest, TestOracleNoFullCones) {
       )
     )
   )");
-  ContentOracle oracle(*wasm);
+  ContentOracle oracle(*wasm, options);
   // The function is exported, and all we know about the parameter $a is that it
   // is some subtype of $A. This is normalized to depth 2 because that is the
   // actual depth of subtypes.