*******************************************************************************/
#include "JBTestUtil.hpp"
#include "compiler/ilgen/IlBuilder.hpp"
// Both path exist, no merge return needed
DEFINE_BUILDER(SubIfThenElseBothPathBuilder,
Int64,
PARAM("valueA", Int64),
PARAM("valueB", Int64) )
{
TR::IlBuilder *elsePath = NULL;
TR::IlBuilder *thenPath = NULL;
IfThenElse(&thenPath, &elsePath, ConstInt64(0));
thenPath->Return(
thenPath->Sub(
thenPath->Load("valueA"),
thenPath->Load("valueB")));
elsePath->Return(
elsePath->Sub(
elsePath->Load("valueB"),
elsePath->Load("valueA")));
return true;
}
// one path exist and will be taken, still need hardcoded Return
DEFINE_BUILDER(SubIfThenNullBuilder,
Int64,
PARAM("valueA", Int64),
DEFINE_BUILDER(TestInt64ReturnType,
Int64,
PARAM("param", Int64))
{
DefineFunction((char *)"testInt64",
(char *)__FILE__,
(char *)TEST_INT64_LINE,
(void *)&testInt64,
Int64,
1,
Int64);
OMR::JitBuilder::IlValue *param = Load("param");
OMR::JitBuilder::IlValue *int64Result = Call("testInt64", 1, param);
OMR::JitBuilder::IlValue *int64Val = ConstInt64(1);
OMR::JitBuilder::IlValue *result = Add(int64Result, int64Val);
Return(result);
return true;
}
DEFINE_BUILDER(TestInt32ReturnType,
Int32,
PARAM("param", Int32))
{
DefineFunction((char *)"testInt32",
(char *)__FILE__,
(char *)TEST_INT32_LINE,
(void *)&testInt32,
bool
InliningRecursiveFibonacciMethod::buildIL()
{
TR::IlBuilder *baseCase=NULL, *recursiveCase=NULL;
IfThenElse(&baseCase, &recursiveCase,
LessThan(
Load("n"),
ConstInt32(2)));
DefineLocal("result", Int32);
baseCase->Store("result",
baseCase-> Load("n"));
TR::IlValue *nMinusOne =
recursiveCase-> Sub(
recursiveCase-> Load("n"),
recursiveCase-> ConstInt32(1));
TR::IlValue *fib_nMinusOne;
if (_inlineDepth > 0)
{
// memory leak here, but just an example
InliningRecursiveFibonacciMethod *inlineFib = new InliningRecursiveFibonacciMethod(this);
fib_nMinusOne = recursiveCase->Call(inlineFib, 1, nMinusOne);
}
else
fib_nMinusOne = recursiveCase->Call("fib", 1, nMinusOne);
TR::IlValue *nMinusTwo =
recursiveCase-> Sub(
recursiveCase-> Load("n"),
recursiveCase-> ConstInt32(2));
TR::IlValue *fib_nMinusTwo;
if (_inlineDepth > 0)
{
// memory leak here, but just an example
InliningRecursiveFibonacciMethod *inlineFib = new InliningRecursiveFibonacciMethod(this);
fib_nMinusTwo = recursiveCase->Call(inlineFib, 1, nMinusTwo);
}
else
fib_nMinusTwo = recursiveCase->Call("fib", 1, nMinusTwo);
recursiveCase->Store("result",
recursiveCase-> Add(fib_nMinusOne, fib_nMinusTwo));
#if defined(RFIB_DEBUG_OUTPUT)
Call("printString", 1,
ConstInt64((int64_t)prefix));
Call("printInt32", 1,
Load("n"));
Call("printString", 1,
ConstInt64((int64_t)middle));
Call("printInt32", 1,
Load("result"));
Call("printString", 1,
ConstInt64((int64_t)suffix));
#endif
Return(
Load("result"));
return true;
}
