bool ParseRepetition(Repetition *Repetition, CallExpr *Call, Assertion *A, vector<ValueDecl*>& References, ASTContext& Ctx) { unsigned Args = Call->getNumArgs(); if (Args < 3) { Report("Repetition must have at least three arguments (min, max, events)", Call->getLocStart(), Ctx) << Call->getSourceRange(); return false; } auto Min = ParseIntegerLiteral(Call->getArg(0), Ctx); Repetition->set_min(Min.getLimitedValue()); auto Max = ParseIntegerLiteral(Call->getArg(1), Ctx); if (Max != INT_MAX) Repetition->set_max(Max.getLimitedValue()); for (unsigned i = 2; i < Args; ++i) { auto Ev = Call->getArg(i); if (!ParseEvent(Repetition->add_event(), Ev, A, References, Ctx)) { Report("Failed to parse repeated event", Ev->getLocStart(), Ctx) << Ev->getSourceRange(); return false; } } return true; }
TEST_F(ResolveConditionTest, SwitchConditionsAreResolved) { { // No runtime information is set in the specialization context. Thus the resolution of the condition must fail. const auto resolved_condition = ResolveCondition(_switch_instruction->getCondition(), _specialization_context); ASSERT_FALSE(resolved_condition); } { // Create runtime information (i.e., an instance of the SomeStruct parameter). const auto runtime_parameter = SomeStruct{std::rand() % 100, std::rand() % 100}; // Initialize the first function argument to this value in the specialization context. This make the value // accessible to the specialization engine. _specialization_context.runtime_value_map.clear(); _specialization_context.runtime_value_map[_switch_instruction_fn->arg_begin()] = std::make_shared<JitConstantRuntimePointer>(&runtime_parameter); const auto resolved_condition = ResolveCondition(_switch_instruction->getCondition(), _specialization_context); // The condition should now be replaced by an integer constant with the correct value from the runtime parameter. ASSERT_TRUE(resolved_condition); ASSERT_EQ(resolved_condition->getType(), llvm::Type::getInt32Ty(*_repository->llvm_context())); const auto resolved_int_condition = llvm::dyn_cast<llvm::ConstantInt>(resolved_condition); const auto resolved_condition_value = static_cast<int32_t>(resolved_int_condition->getLimitedValue(std::numeric_limits<uint64_t>::max())); ASSERT_EQ(resolved_condition_value, runtime_parameter.a); } }