make 11 apps/c_backend/pipeline_cpp_generator.cpp return Call::make(type_of<int>(), "cpp_extern_toplevel", {cast<int>(arg1), cast<float>(arg2)}, Call::ExternCPlusPlus); make 15 apps/c_backend/pipeline_cpp_generator.cpp return Call::make(type_of<int>(), "namespace1::cpp_extern", {cast<int>(arg1), cast<float>(arg2)}, Call::ExternCPlusPlus); make 19 apps/c_backend/pipeline_cpp_generator.cpp return Call::make(type_of<int>(), "namespace2::cpp_extern_1", {cast<int>(arg1), cast<float>(arg2)}, Call::ExternCPlusPlus); make 22 apps/c_backend/pipeline_cpp_generator.cpp return Call::make(type_of<int>(), "namespace2::cpp_extern_2", {cast<int>(arg1), cast<float>(arg2)}, Call::ExternCPlusPlus); make 25 apps/c_backend/pipeline_cpp_generator.cpp return Call::make(type_of<int>(), "namespace2::cpp_extern_3", {cast<int>(arg1), cast<float>(arg2)}, Call::ExternCPlusPlus); make 29 apps/c_backend/pipeline_cpp_generator.cpp return Call::make(type_of<int>(), "namespace_outer::cpp_extern", {cast<int>(arg1), cast<float>(arg2)}, Call::ExternCPlusPlus); make 32 apps/c_backend/pipeline_cpp_generator.cpp return Call::make(type_of<int>(), "namespace_outer::namespace_inner::cpp_extern", {cast<int>(arg1), cast<float>(arg2)}, Call::ExternCPlusPlus); make 36 apps/c_backend/pipeline_cpp_generator.cpp return Call::make(type_of<int>(), "namespace_shared_outer::cpp_extern_1", {cast<int>(arg1), cast<float>(arg2)}, Call::ExternCPlusPlus); make 39 apps/c_backend/pipeline_cpp_generator.cpp return Call::make(type_of<int>(), "namespace_shared_outer::cpp_extern_2", {cast<int>(arg1), cast<float>(arg2)}, Call::ExternCPlusPlus); make 42 apps/c_backend/pipeline_cpp_generator.cpp return Call::make(type_of<int>(), "namespace_shared_outer::inner::cpp_extern_1", {cast<int>(arg1), cast<float>(arg2)}, Call::ExternCPlusPlus); make 45 apps/c_backend/pipeline_cpp_generator.cpp return Call::make(type_of<int>(), "namespace_shared_outer::inner::cpp_extern_2", {cast<int>(arg1), cast<float>(arg2)}, Call::ExternCPlusPlus); make 123 src/AddImageChecks.cpp Expr min_required = Variable::make(Int(32), name + ".min." + dim + ".required"); make 126 src/AddImageChecks.cpp Expr extent_required = Variable::make(Int(32), name + ".extent." + dim + ".required"); make 129 src/AddImageChecks.cpp Expr stride_required = Variable::make(Int(32), name + ".stride." + dim + ".required"); make 194 src/AddImageChecks.cpp Expr query_buf = Variable::make(type_of<struct halide_buffer_t *>(), make 197 src/AddImageChecks.cpp Expr min = Call::make(Int(32), Call::buffer_get_min, make 199 src/AddImageChecks.cpp Expr max = Call::make(Int(32), Call::buffer_get_max, make 210 src/AddImageChecks.cpp Expr handle = Variable::make(type_of<buffer_t *>(), name + ".buffer", make 212 src/AddImageChecks.cpp Expr inference_mode = Call::make(Bool(), Call::buffer_is_bounds_query, make 225 src/AddImageChecks.cpp Expr type_code = Variable::make(UInt(8), type_code_name, image, param, rdom); make 226 src/AddImageChecks.cpp Expr type_bits = Variable::make(UInt(8), type_bits_name, image, param, rdom); make 227 src/AddImageChecks.cpp Expr type_lanes = Variable::make(UInt(16), type_lanes_name, image, param, rdom); make 228 src/AddImageChecks.cpp Expr error = Call::make(Int(32), "halide_error_bad_type", make 235 src/AddImageChecks.cpp AssertStmt::make((type_code == type.code()) && make 252 src/AddImageChecks.cpp Expr actual_min = Variable::make(Int(32), actual_min_name, image, param, rdom); make 253 src/AddImageChecks.cpp Expr actual_extent = Variable::make(Int(32), actual_extent_name, image, param, rdom); make 254 src/AddImageChecks.cpp Expr actual_stride = Variable::make(Int(32), actual_stride_name, image, param, rdom); make 273 src/AddImageChecks.cpp Expr min_required_var = Variable::make(Int(32), min_required_name); make 274 src/AddImageChecks.cpp Expr extent_required_var = Variable::make(Int(32), extent_required_name); make 288 src/AddImageChecks.cpp Expr oob_error = Call::make(Int(32), "halide_error_access_out_of_bounds", make 292 src/AddImageChecks.cpp asserts_required.push_back(AssertStmt::make(oob_condition, oob_error)); make 306 src/AddImageChecks.cpp stride_required = (Variable::make(Int(32), name + ".stride." + last_dim + ".required") * make 307 src/AddImageChecks.cpp Variable::make(Int(32), name + ".extent." + last_dim + ".required")); make 321 src/AddImageChecks.cpp Expr allocation_size_error = Call::make(Int(32), "halide_error_buffer_allocation_too_large", make 323 src/AddImageChecks.cpp Stmt check = AssertStmt::make(actual_size <= max_size, allocation_size_error); make 332 src/AddImageChecks.cpp Expr last_dim = Variable::make(Int(64), name + ".total_extent." + std::to_string(j-1)); make 334 src/AddImageChecks.cpp Expr this_dim_var = Variable::make(Int(64), name + ".total_extent." + dim); make 336 src/AddImageChecks.cpp Expr error = Call::make(Int(32), "halide_error_buffer_extents_too_large", make 338 src/AddImageChecks.cpp Stmt check = AssertStmt::make(this_dim_var <= max_size, error); make 344 src/AddImageChecks.cpp Expr negative_extent_error = Call::make(Int(32), "halide_error_buffer_extents_negative", make 346 src/AddImageChecks.cpp asserts_required.push_back(AssertStmt::make(negative_extent_condition, negative_extent_error)); make 352 src/AddImageChecks.cpp builder.buffer_memory = Variable::make(type_of<struct halide_buffer_t *>(), name + ".buffer"); make 353 src/AddImageChecks.cpp builder.shape_memory = Call::make(type_of<struct halide_dimension_t *>(), make 360 src/AddImageChecks.cpp builder.mins.push_back(Variable::make(Int(32), name + ".min." + dim + ".proposed")); make 361 src/AddImageChecks.cpp builder.extents.push_back(Variable::make(Int(32), name + ".extent." + dim + ".proposed")); make 362 src/AddImageChecks.cpp builder.strides.push_back(Variable::make(Int(32), name + ".stride." + dim + ".proposed")); make 364 src/AddImageChecks.cpp Stmt rewrite = Evaluate::make(builder.build()); make 366 src/AddImageChecks.cpp rewrite = IfThenElse::make(inference_mode, rewrite); make 379 src/AddImageChecks.cpp Expr stride_orig = Variable::make(Int(32), stride_name, image, param, rdom); make 380 src/AddImageChecks.cpp Expr extent_orig = Variable::make(Int(32), extent_name, image, param, rdom); make 381 src/AddImageChecks.cpp Expr min_orig = Variable::make(Int(32), min_name, image, param, rdom); make 383 src/AddImageChecks.cpp Expr stride_required = Variable::make(Int(32), stride_name + ".required"); make 384 src/AddImageChecks.cpp Expr extent_required = Variable::make(Int(32), extent_name + ".required"); make 385 src/AddImageChecks.cpp Expr min_required = Variable::make(Int(32), min_name + ".required"); make 387 src/AddImageChecks.cpp Expr stride_proposed = Variable::make(Int(32), stride_name + ".proposed"); make 388 src/AddImageChecks.cpp Expr extent_proposed = Variable::make(Int(32), extent_name + ".proposed"); make 389 src/AddImageChecks.cpp Expr min_proposed = Variable::make(Int(32), min_name + ".proposed"); make 413 src/AddImageChecks.cpp min_constrained = Variable::make(Int(32), min0_name); make 420 src/AddImageChecks.cpp extent_constrained = Variable::make(Int(32), extent0_name); make 463 src/AddImageChecks.cpp Expr error = Call::make(Int(32), "halide_error_constraints_make_required_region_smaller", make 466 src/AddImageChecks.cpp asserts_proposed.push_back(AssertStmt::make((!inference_mode) || check, error)); make 482 src/AddImageChecks.cpp Expr constrained_var = Variable::make(Int(32), name + ".constrained"); make 492 src/AddImageChecks.cpp Expr error = Call::make(Int(32), "halide_error_constraint_violated", make 497 src/AddImageChecks.cpp asserts_constrained.push_back(AssertStmt::make(var == constrained_var, error)); make 502 src/AddImageChecks.cpp Expr host_ptr = Variable::make(Handle(), host_name); make 505 src/AddImageChecks.cpp Expr error = Call::make(Int(32), "halide_error_unaligned_host_ptr", make 507 src/AddImageChecks.cpp asserts_host_alignment.push_back(AssertStmt::make(align_condition, error)); make 514 src/AddImageChecks.cpp s = Block::make(asserts_host_alignment[i-1], s); make 520 src/AddImageChecks.cpp s = Block::make(dims_no_overflow_asserts[i-1], s); make 525 src/AddImageChecks.cpp s = LetStmt::make(lets_overflow[i-1].first, lets_overflow[i-1].second, s); make 542 src/AddImageChecks.cpp s = Block::make(asserts_constrained[i-1], s); make 547 src/AddImageChecks.cpp s = Block::make(asserts_required[i-1], s); make 552 src/AddImageChecks.cpp s = Block::make(asserts_elem_size[i-1], s); make 558 src/AddImageChecks.cpp s = IfThenElse::make(!maybe_return_condition, s); make 562 src/AddImageChecks.cpp s = Block::make(buffer_rewrites[i-1], s); make 569 src/AddImageChecks.cpp s = Block::make(asserts_proposed[i-1], s); make 575 src/AddImageChecks.cpp s = LetStmt::make(lets_proposed[i-1].first, lets_proposed[i-1].second, s); make 580 src/AddImageChecks.cpp s = LetStmt::make(lets_constrained[i-1].first, lets_constrained[i-1].second, s); make 585 src/AddImageChecks.cpp s = LetStmt::make(lets_required[i-1].first, lets_required[i-1].second, s); make 57 src/AddParameterChecks.cpp Expr constrained_var = Variable::make(param.type(), constrained_name); make 58 src/AddParameterChecks.cpp Expr constrained_value = Variable::make(param.type(), i.first, param); make 90 src/AddParameterChecks.cpp s = LetStmt::make(lets[i].first, lets[i].second, s); make 123 src/AddParameterChecks.cpp Expr error = Call::make(Int(32), error_call_name, make 127 src/AddParameterChecks.cpp s = Block::make(AssertStmt::make(p.condition, error), s); make 38 src/AlignLoads.cpp return mutate(Load::make(load->type.with_lanes(index.type().lanes()), load->name, make 109 src/AlignLoads.cpp Expr dense_index = Ramp::make(dense_base, 1, lanes*stride); make 122 src/AlignLoads.cpp Expr native_load = make_load(op, Ramp::make(ramp->base, 1, native_lanes)); make 136 src/AlignLoads.cpp slices.push_back(make_load(op, Ramp::make(slice_base, 1, slice_lanes))); make 147 src/AlignLoads.cpp Expr aligned_load = make_load(op, Ramp::make(aligned_base, 1, lanes*2)); make 170 src/AlignLoads.cpp result = LetType::make(op->name, value, body); make 42 src/AllocationBoundsInference.cpp required[i] = Interval(Variable::make(Int(32), prefix + ".min"), make 43 src/AllocationBoundsInference.cpp Variable::make(Int(32), prefix + ".max")); make 51 src/AllocationBoundsInference.cpp stmt = Realize::make(op->name, op->types, op->bounds, op->condition, new_body); make 101 src/AllocationBoundsInference.cpp Expr min_var = Variable::make(Int(32), min_name); make 102 src/AllocationBoundsInference.cpp Expr max_var = Variable::make(Int(32), max_name); make 107 src/AllocationBoundsInference.cpp Expr error_msg = Call::make(Int(32), "halide_error_explicit_bounds_too_small", make 112 src/AllocationBoundsInference.cpp stmt = Block::make(AssertStmt::make(min_var <= b[i].min, error_msg), stmt); make 115 src/AllocationBoundsInference.cpp stmt = Block::make(AssertStmt::make(max_var >= b[i].max, error_msg), stmt); make 118 src/AllocationBoundsInference.cpp stmt = LetStmt::make(extent_name, extent, stmt); make 119 src/AllocationBoundsInference.cpp stmt = LetStmt::make(min_name, min, stmt); make 120 src/AllocationBoundsInference.cpp stmt = LetStmt::make(max_name, max, stmt); make 16 src/ApplySplit.cpp Expr outer = Variable::make(Int(32), prefix + split.outer); make 17 src/ApplySplit.cpp Expr outer_max = Variable::make(Int(32), prefix + split.outer + ".loop_max"); make 19 src/ApplySplit.cpp Expr inner = Variable::make(Int(32), prefix + split.inner); make 20 src/ApplySplit.cpp Expr old_max = Variable::make(Int(32), prefix + split.old_var + ".loop_max"); make 21 src/ApplySplit.cpp Expr old_min = Variable::make(Int(32), prefix + split.old_var + ".loop_min"); make 22 src/ApplySplit.cpp Expr old_extent = Variable::make(Int(32), prefix + split.old_var + ".loop_extent"); make 28 src/ApplySplit.cpp Expr base_var = Variable::make(Int(32), base_name); make 30 src/ApplySplit.cpp Expr old_var = Variable::make(Int(32), old_var_name); make 61 src/ApplySplit.cpp Expr rebased_var = Variable::make(Int(32), rebased_var_name); make 81 src/ApplySplit.cpp base = Min::make(base, old_max + (1 - split.factor)); make 94 src/ApplySplit.cpp Expr fused = Variable::make(Int(32), prefix + split.old_var); make 95 src/ApplySplit.cpp Expr inner_min = Variable::make(Int(32), prefix + split.inner + ".loop_min"); make 96 src/ApplySplit.cpp Expr outer_min = Variable::make(Int(32), prefix + split.outer + ".loop_min"); make 97 src/ApplySplit.cpp Expr inner_extent = Variable::make(Int(32), prefix + split.inner + ".loop_extent"); make 137 src/ApplySplit.cpp Expr old_var_extent = Variable::make(Int(32), prefix + split.old_var + ".loop_extent"); make 138 src/ApplySplit.cpp Expr old_var_max = Variable::make(Int(32), prefix + split.old_var + ".loop_max"); make 139 src/ApplySplit.cpp Expr old_var_min = Variable::make(Int(32), prefix + split.old_var + ".loop_min"); make 151 src/ApplySplit.cpp Expr inner_extent = Variable::make(Int(32), prefix + split.inner + ".loop_extent"); make 152 src/ApplySplit.cpp Expr outer_extent = Variable::make(Int(32), prefix + split.outer + ".loop_extent"); make 108 src/AssociativeOpsTable.cpp Expr x0 = Variable::make(t, "x0"); \ make 109 src/AssociativeOpsTable.cpp Expr y0 = Variable::make(t, "y0"); \ make 110 src/AssociativeOpsTable.cpp Expr x1 = Variable::make(t, "x1"); \ make 111 src/AssociativeOpsTable.cpp Expr y1 = Variable::make(t, "y1"); \ make 112 src/AssociativeOpsTable.cpp Expr k0 = Variable::make(t, "k0"); \ make 215 src/AssociativeOpsTable.cpp Expr k0_uint16 = Variable::make(UInt(16), "k0"); make 216 src/AssociativeOpsTable.cpp Expr k0_uint32 = Variable::make(UInt(32), "k0"); make 217 src/AssociativeOpsTable.cpp Expr k0_uint64 = Variable::make(UInt(64), "k0"); make 235 src/AssociativeOpsTable.cpp Expr k0_uint32 = Variable::make(UInt(32), "k0"); make 236 src/AssociativeOpsTable.cpp Expr k0_uint64 = Variable::make(UInt(64), "k0"); make 253 src/AssociativeOpsTable.cpp Expr k0_uint64 = Variable::make(UInt(64), "k0"); make 75 src/Associativity.cpp expr = Variable::make(op->type, op_x_names[op->value_index]); make 203 src/Associativity.cpp replacement.push_back({y_part, Variable::make(y_part.type(), op_y_names[index])}); make 237 src/Associativity.cpp assoc_op.pattern.ops[0] = Variable::make(t, op_y_names[0]); make 499 src/Associativity.cpp replacement.emplace(assoc_op.xs[i].var, Variable::make(result.xs[i].expr.type(), result.xs[i].var)); make 502 src/Associativity.cpp replacement.emplace(assoc_op.ys[i].var, Variable::make(result.ys[i].expr.type(), result.ys[i].var)); make 530 src/Associativity.cpp Expr x = Variable::make(t, "x"); make 531 src/Associativity.cpp Expr y = Variable::make(t, "y"); make 532 src/Associativity.cpp Expr x_idx = Variable::make(Int(32), "x_idx"); make 533 src/Associativity.cpp Expr f_call_0 = Call::make(t, "f", {x_idx}, Call::CallType::Halide, nullptr, 0); make 536 src/Associativity.cpp check_associativity("f", {x_idx}, {Cast::make(UInt(8), min(Cast::make(UInt(16), y + f_call_0), make_const(t, 255)))}, make 538 src/Associativity.cpp AssociativePattern(Cast::make(UInt(8), min(Cast::make(UInt(16), x + y), make_const(t, 255))), make_const(t, 0), true), make 545 src/Associativity.cpp check_associativity("f", {x_idx}, {Cast::make(UInt(8), min(Cast::make(UInt(16), y + f_call_0), Cast::make(UInt(16), make_const(t, 255))))}, make 547 src/Associativity.cpp AssociativePattern(Cast::make(UInt(8), min(Cast::make(UInt(16), x + y), make_const(t, 255))), make_const(t, 0), true), make 575 src/Associativity.cpp Expr x = Variable::make(t, "x"); make 576 src/Associativity.cpp Expr y = Variable::make(t, "y"); make 577 src/Associativity.cpp Expr x_idx = Variable::make(Int(32), "x_idx"); make 578 src/Associativity.cpp Expr f_call_0 = Call::make(t, "f", {x_idx}, Call::CallType::Halide, nullptr, 0); make 581 src/Associativity.cpp check_associativity("f", {x_idx}, {And::make(y, f_call_0)}, make 583 src/Associativity.cpp AssociativePattern(And::make(x, y), const_true(), true), make 590 src/Associativity.cpp check_associativity("f", {x_idx}, {Or::make(y, f_call_0)}, make 592 src/Associativity.cpp AssociativePattern(Or::make(x, y), const_false(), true), make 600 src/Associativity.cpp Expr x = Variable::make(t, "x"); make 601 src/Associativity.cpp Expr y = Variable::make(t, "y"); make 602 src/Associativity.cpp Expr z = Variable::make(t, "z"); make 603 src/Associativity.cpp Expr rx = Variable::make(t, "rx"); make 607 src/Associativity.cpp xs[i] = Variable::make(t, "x" + std::to_string(i)); make 608 src/Associativity.cpp ys[i] = Variable::make(t, "y" + std::to_string(i)); make 609 src/Associativity.cpp zs[i] = Variable::make(t, "z" + std::to_string(i)); make 612 src/Associativity.cpp Expr f_call_0 = Call::make(t, "f", {x}, Call::CallType::Halide, nullptr, 0); make 613 src/Associativity.cpp Expr f_call_1 = Call::make(t, "f", {x}, Call::CallType::Halide, nullptr, 1); make 614 src/Associativity.cpp Expr f_call_2 = Call::make(t, "f", {x}, Call::CallType::Halide, nullptr, 2); make 615 src/Associativity.cpp Expr g_call_0 = Call::make(t, "g", {rx}, Call::CallType::Halide, nullptr, 0); make 616 src/Associativity.cpp Expr g_call_1 = Call::make(t, "g", {rx}, Call::CallType::Halide, nullptr, 1); make 619 src/Associativity.cpp check_associativity("f", {x}, {min(f_call_0, y + Cast::make(Int(16), z))}, make 623 src/Associativity.cpp {Replacement("y", y + Cast::make(Int(16), z))}, make 733 src/Associativity.cpp Expr ry = Variable::make(t, "ry"); make 734 src/Associativity.cpp Expr f_xy_call_0 = Call::make(t, "f", {x, y}, Call::CallType::Halide, nullptr, 0); make 735 src/Associativity.cpp Expr f_xy_call_1 = Call::make(t, "f", {x, y}, Call::CallType::Halide, nullptr, 1); make 736 src/Associativity.cpp Expr f_xy_call_2 = Call::make(t, "f", {x, y}, Call::CallType::Halide, nullptr, 2); make 737 src/Associativity.cpp Expr f_xy_call_3 = Call::make(t, "f", {x, y}, Call::CallType::Halide, nullptr, 3); make 738 src/Associativity.cpp Expr g_xy_call_0 = Call::make(t, "g", {rx, ry}, Call::CallType::Halide, nullptr, 0); make 53 src/Bounds.cpp return simplify(Min::make(a, b)); make 63 src/Bounds.cpp return simplify(Max::make(a, b)); make 72 src/Bounds.cpp return simplify(Cast::make(cast->type, a)); make 147 src/Bounds.cpp interval = Interval::single_point(Cast::make(to, a.min)); make 197 src/Bounds.cpp if (interval.has_lower_bound()) interval.min = Cast::make(to, interval.min); make 198 src/Bounds.cpp if (interval.has_upper_bound()) interval.max = Cast::make(to, interval.max); make 437 src/Bounds.cpp interval = Interval(make_zero(t), Max::make(abs(b.min), abs(b.max)) - make_one(t)); make 442 src/Bounds.cpp interval = Interval(make_zero(t), Max::make(abs(b.min), abs(b.max))); make 553 src/Bounds.cpp Load::make(op->type.element_of(), op->name, interval.min, make 565 src/Bounds.cpp Expr var = Variable::make(op->base.type(), var_name); make 604 src/Bounds.cpp Expr call = Call::make(t, op->name, new_args, op->call_type, make 612 src/Bounds.cpp interval = Interval::single_point(Call::make(t, Call::abs, {a.max}, Call::PureIntrinsic)); make 614 src/Bounds.cpp interval.max = Max::make(Cast::make(t, -a.min), Cast::make(t, a.max)); make 616 src/Bounds.cpp a.min = Call::make(t, Call::abs, {a.min}, Call::PureIntrinsic); make 617 src/Bounds.cpp a.max = Call::make(t, Call::abs, {a.max}, Call::PureIntrinsic); make 618 src/Bounds.cpp interval.max = Max::make(a.min, a.max); make 634 src/Bounds.cpp Expr equivalent_select = Select::make(op->args[0], op->args[1], op->args[2]); make 655 src/Bounds.cpp Call::make(t, op->name, {interval.min}, op->call_type, make 657 src/Bounds.cpp Call::make(t, op->name, {interval.max}, op->call_type, make 670 src/Bounds.cpp interval = Interval(Call::make(Int(32), Call::buffer_get_min, op->args, Call::Extern), make 671 src/Bounds.cpp Call::make(Int(32), Call::buffer_get_max, op->args, Call::Extern)); make 700 src/Bounds.cpp var.min = Variable::make(op->value.type().element_of(), min_name); make 710 src/Bounds.cpp var.max = Variable::make(op->value.type().element_of(), max_name); make 720 src/Bounds.cpp interval.min = Let::make(min_name, val.min, interval.min); make 723 src/Bounds.cpp interval.min = Let::make(max_name, val.max, interval.min); make 729 src/Bounds.cpp interval.max = Let::make(min_name, val.min, interval.max); make 732 src/Bounds.cpp interval.max = Let::make(max_name, val.max, interval.max); make 805 src/Bounds.cpp Expr min = Min::make(a[i].min, b[i].min); make 808 src/Bounds.cpp Expr max_plus_one = Max::make(max_a, max_b); make 1005 src/Bounds.cpp Stmt then_case = Evaluate::make(op->args[1]); make 1006 src/Bounds.cpp Stmt else_case = Evaluate::make(op->args[2]); make 1007 src/Bounds.cpp Stmt equivalent_if = IfThenElse::make(op->args[0], then_case, else_case); make 1072 src/Bounds.cpp scope.push(op->name, Interval(Variable::make(op->value.type(), min_name), make 1073 src/Bounds.cpp Variable::make(op->value.type(), max_name))); make 1082 src/Bounds.cpp box[i].min = Let::make(max_name, value_bounds.max, box[i].min); make 1085 src/Bounds.cpp box[i].min = Let::make(min_name, value_bounds.min, box[i].min); make 1090 src/Bounds.cpp box[i].max = Let::make(max_name, value_bounds.max, box[i].max); make 1093 src/Bounds.cpp box[i].max = Let::make(min_name, value_bounds.min, box[i].max); make 1489 src/Bounds.cpp check(scope, Select::make(x < 4, x, x+100), 0, 110); make 1494 src/Bounds.cpp check(scope, Load::make(Int(8), "buf", x, Buffer<>(), Parameter(), const_true()), make 1496 src/Bounds.cpp check(scope, y + (Let::make("y", x+3, y - x + 10)), y + 3, y + 23); // Once again, we don't know that y is correlated with x make 1514 src/Bounds.cpp check(scope, Ramp::make(x*2, 5, 5), 0, 40); make 1515 src/Bounds.cpp check(scope, Broadcast::make(x*2, 5), 0, 20); make 1516 src/Bounds.cpp check(scope, Broadcast::make(3, 4), 3, 3); make 1538 src/Bounds.cpp Expr u8_1 = cast<uint8_t>(Load::make(Int(8), "buf", x, Buffer<>(), Parameter(), const_true())); make 1539 src/Bounds.cpp Expr u8_2 = cast<uint8_t>(Load::make(Int(8), "buf", x + 17, Buffer<>(), Parameter(), const_true())); make 1550 src/Bounds.cpp Stmt loop = For::make("x", 3, 10, ForType::Serial, DeviceAPI::Host, make 1551 src/Bounds.cpp Provide::make("output", make 1552 src/Bounds.cpp {Add::make(Call::make(in, input_site_1), make 1553 src/Bounds.cpp Call::make(in, input_site_2))}, make 86 src/BoundsInference.cpp Interval in(Variable::make(Int(32), op->name + ".loop_min"), make 87 src/BoundsInference.cpp Variable::make(Int(32), op->name + ".loop_max")); make 156 src/BoundsInference.cpp Expr cond_val = Call::make(val.type(), make 161 src/BoundsInference.cpp cond_val = Call::make(cond_val.type(), make 309 src/BoundsInference.cpp Expr min = Variable::make(Int(32), last_stage + dim + ".min"); make 310 src/BoundsInference.cpp Expr max = Variable::make(Int(32), last_stage + dim + ".max"); make 342 src/BoundsInference.cpp Expr outer_query = Variable::make(type_of<struct halide_buffer_t *>(), outer_query_name); make 344 src/BoundsInference.cpp Expr inner_query = Variable::make(type_of<struct halide_buffer_t *>(), inner_query_name); make 346 src/BoundsInference.cpp Expr outer_min = Call::make(Int(32), Call::buffer_get_min, make 348 src/BoundsInference.cpp Expr outer_max = Call::make(Int(32), Call::buffer_get_max, make 351 src/BoundsInference.cpp Expr inner_min = Call::make(Int(32), Call::buffer_get_min, make 353 src/BoundsInference.cpp Expr inner_max = Call::make(Int(32), Call::buffer_get_max, make 357 src/BoundsInference.cpp Expr shift = Min::make(0, outer_max - inner_max); make 362 src/BoundsInference.cpp s = LetStmt::make(func.name() + ".s0." + func_args[i] + ".max", new_max, s); make 363 src/BoundsInference.cpp s = LetStmt::make(func.name() + ".s0." + func_args[i] + ".min", new_min, s); make 370 src/BoundsInference.cpp s = LetStmt::make(func.name() + ".outer_bounds_query", make 371 src/BoundsInference.cpp Variable::make(type_of<struct halide_buffer_t *>(), func.name() + ".o0.bounds_query"), s); make 382 src/BoundsInference.cpp Expr inner_query = Variable::make(type_of<struct halide_buffer_t *>(), inner_query_name); make 384 src/BoundsInference.cpp Expr new_min = Call::make(Int(32), Call::buffer_get_min, make 386 src/BoundsInference.cpp Expr new_max = Call::make(Int(32), Call::buffer_get_max, make 389 src/BoundsInference.cpp s = LetStmt::make(func.name() + ".s0." + func_args[i] + ".max", new_max, s); make 390 src/BoundsInference.cpp s = LetStmt::make(func.name() + ".s0." + func_args[i] + ".min", new_min, s); make 410 src/BoundsInference.cpp Expr min_required = Variable::make(Int(32), min_var); make 411 src/BoundsInference.cpp Expr max_required = Variable::make(Int(32), max_var); make 427 src/BoundsInference.cpp s = LetStmt::make(min_var, bound.min, s); make 428 src/BoundsInference.cpp s = LetStmt::make(max_var, bound.min + bound.extent - 1, s); make 432 src/BoundsInference.cpp s = LetStmt::make(min_var + "_unbounded", min_required, s); make 433 src/BoundsInference.cpp s = LetStmt::make(max_var + "_unbounded", max_required, s); make 445 src/BoundsInference.cpp s = LetStmt::make(min_var, min_required, s); make 446 src/BoundsInference.cpp s = LetStmt::make(max_var, max_required, s); make 455 src/BoundsInference.cpp s = LetStmt::make(arg + ".min", Variable::make(Int(32), arg + ".max"), s); make 457 src/BoundsInference.cpp s = LetStmt::make(arg + ".min", b[d].min, s); make 459 src/BoundsInference.cpp s = LetStmt::make(arg + ".max", b[d].max, s); make 465 src/BoundsInference.cpp s = LetStmt::make(arg + ".min", rvar.min, s); make 466 src/BoundsInference.cpp s = LetStmt::make(arg + ".max", rvar.extent + rvar.min - 1, s); make 504 src/BoundsInference.cpp bounds_inference_args.push_back(Variable::make(type_of<struct halide_buffer_t *>(), name)); make 513 src/BoundsInference.cpp Expr in_buf = Variable::make(type_of<struct halide_buffer_t *>(), name + ".buffer"); make 518 src/BoundsInference.cpp Expr alloca_size = Call::make(Int(32), Call::size_of_halide_buffer_t, {}, Call::Intrinsic); make 519 src/BoundsInference.cpp Expr query_buf = Call::make(type_of<struct halide_buffer_t *>(), Call::alloca, make 521 src/BoundsInference.cpp Expr query_shape = Call::make(type_of<struct halide_dimension_t *>(), Call::alloca, make 523 src/BoundsInference.cpp query_buf = Call::make(type_of<struct halide_buffer_t *>(), Call::buffer_init_from_buffer, make 527 src/BoundsInference.cpp Expr buf = Variable::make(type_of<struct halide_buffer_t *>(), query_name, b, p, ReductionDomain()); make 545 src/BoundsInference.cpp Expr min = Variable::make(Int(32), prefix + ".min"); make 546 src/BoundsInference.cpp Expr max = Variable::make(Int(32), prefix + ".max"); make 554 src/BoundsInference.cpp bounds_inference_args.push_back(Variable::make(type_of<struct halide_buffer_t *>(), buf_name)); make 568 src/BoundsInference.cpp cast<uint64_t>(Call::make(Int(32), Call::size_of_halide_buffer_t, {}, Call::Intrinsic)); make 570 src/BoundsInference.cpp Evaluate::make(Call::make(Int(32), "halide_msan_annotate_memory_is_initialized", make 573 src/BoundsInference.cpp annotate = Block::make(annotate, mark_buffer); make 585 src/BoundsInference.cpp Expr result = Variable::make(Int(32), result_name); make 586 src/BoundsInference.cpp Expr error = Call::make(Int(32), "halide_error_bounds_inference_call_failed", make 588 src/BoundsInference.cpp Stmt check = AssertStmt::make(EQ::make(result, 0), error); make 590 src/BoundsInference.cpp check = LetStmt::make(result_name, e, check); make 593 src/BoundsInference.cpp check = Block::make(annotate, check); make 597 src/BoundsInference.cpp s = Block::make(check, s); make 601 src/BoundsInference.cpp s = LetStmt::make(lets[i].first, lets[i].second, s); make 614 src/BoundsInference.cpp Interval(Variable::make(Int(32), arg + ".min"), make 615 src/BoundsInference.cpp Variable::make(Int(32), arg + ".max"))); make 620 src/BoundsInference.cpp result.push(rv.var, Interval(Variable::make(Int(32), arg + ".min"), make 621 src/BoundsInference.cpp Variable::make(Int(32), arg + ".max"))); make 740 src/BoundsInference.cpp Expr buf = Variable::make(type_of<struct halide_buffer_t *>(), buf_name); make 741 src/BoundsInference.cpp Expr min = Call::make(Int(32), Call::buffer_get_min, make 743 src/BoundsInference.cpp Expr max = Call::make(Int(32), Call::buffer_get_max, make 816 src/BoundsInference.cpp Expr min = Variable::make(Int(32), buffer_name + ".min." + std::to_string(d), buf); make 817 src/BoundsInference.cpp Expr extent = Variable::make(Int(32), buffer_name + ".extent." + std::to_string(d), buf); make 923 src/BoundsInference.cpp body = LetStmt::make(var + ".max", Variable::make(Int(32), var + ".min"), body); make 925 src/BoundsInference.cpp body = LetStmt::make(var + ".max", box[i].max, body); make 928 src/BoundsInference.cpp body = LetStmt::make(var + ".min", box[i].min, body); make 954 src/BoundsInference.cpp body = LetStmt::make(var + ".min", in.min, body); make 955 src/BoundsInference.cpp body = LetStmt::make(var + ".max", in.max, body); make 960 src/BoundsInference.cpp Expr val = Variable::make(Int(32), var); make 961 src/BoundsInference.cpp body = LetStmt::make(var + ".min", val, body); make 962 src/BoundsInference.cpp body = LetStmt::make(var + ".max", val, body); make 973 src/BoundsInference.cpp body = LetStmt::make(lets[i-1].first, lets[i-1].second, body); make 978 src/BoundsInference.cpp stmt = For::make(op->name, op->min, op->extent, op->for_type, op->device_api, body); make 1005 src/BoundsInference.cpp s = For::make("<outermost>", 0, 1, ForType::Serial, DeviceAPI::None, s); make 36 src/Buffer.cpp return Call::make(buf, int_args); make 177 src/CSE.cpp expr = Load::make(op->type, op->name, index, op->image, op->param, predicate); make 192 src/CSE.cpp stmt = Store::make(op->name, value, index, op->param, predicate); make 292 src/CSE.cpp replacements[e.expr] = Variable::make(e.expr.type(), name); make 310 src/CSE.cpp e = Let::make(lets[i-1].first, value, e); make 341 src/CSE.cpp expr = Variable::make(var->type, iter->second); make 350 src/CSE.cpp expr = Let::make(new_name, value, body); make 373 src/CSE.cpp e = Let::make(name, exprs[i-1], e); make 381 src/CSE.cpp Expr x = Variable::make(Int(32), "x"); make 382 src/CSE.cpp Expr y = Variable::make(Int(32), "y"); make 386 src/CSE.cpp t[i] = Variable::make(Int(32), "t" + std::to_string(i)); make 387 src/CSE.cpp tf[i] = Variable::make(Float(32), "t" + std::to_string(i)); make 450 src/CSE.cpp Expr load = Load::make(Int(32), "buf", index, Buffer<>(), Parameter(), const_true()); make 451 src/CSE.cpp Expr pred_load = Load::make(Int(32), "buf", index, Buffer<>(), Parameter(), pred); make 454 src/CSE.cpp Expr t2 = Variable::make(Bool(), "t2"); make 455 src/CSE.cpp Expr cse_load = Load::make(Int(32), "buf", t[3], Buffer<>(), Parameter(), const_true()); make 456 src/CSE.cpp Expr cse_pred_load = Load::make(Int(32), "buf", t[3], Buffer<>(), Parameter(), t2); make 469 src/CSE.cpp Expr load = Load::make(Int(32), "buf", index, Buffer<>(), Parameter(), const_true()); make 470 src/CSE.cpp Expr pred_load = Load::make(Int(32), "buf", index, Buffer<>(), Parameter(), pred); make 473 src/CSE.cpp Expr t2 = Variable::make(Bool(), "t2"); make 474 src/CSE.cpp Expr cse_load = Load::make(Int(32), "buf", select(t2, t[1] + 2, t[1] + 10), Buffer<>(), Parameter(), const_true()); make 475 src/CSE.cpp Expr cse_pred_load = Load::make(Int(32), "buf", select(t2, t[1] + 2, t[1] + 10), Buffer<>(), Parameter(), t2); make 489 src/CSE.cpp e = Call::make(Int(32), "dummy", {handle_a, handle_b, handle_c}, Call::Extern); make 491 src/CSE.cpp Expr t0 = Variable::make(handle_b.type(), "t0"); make 492 src/CSE.cpp correct = Let::make("t0", handle_b, make 493 src/CSE.cpp Call::make(Int(32), "dummy", {handle_a, t0, t0}, Call::Extern)); make 141 src/CanonicalizeGPUVars.cpp Expr new_var = Variable::make(Int(32), name); make 154 src/CanonicalizeGPUVars.cpp stmt = For::make(name, min, extent, op->for_type, op->device_api, body); make 165 src/CanonicalizeGPUVars.cpp Expr new_var = Variable::make(Int(32), name); make 175 src/CanonicalizeGPUVars.cpp stmt = LetStmt::make(name, value, body); make 194 src/CanonicalizeGPUVars.cpp stmt = IfThenElse::make(condition, then_case, else_case); make 63 src/CodeGen_ARM.cpp Expr vector = Variable::make(t, "*"); make 64 src/CodeGen_ARM.cpp Expr w_vector = Variable::make(w, "*"); make 65 src/CodeGen_ARM.cpp Expr ws_vector = Variable::make(ws, "*"); make 746 src/CodeGen_ARM.cpp Expr slice_ramp = Ramp::make(slice_base, ramp->stride, intrin_type.lanes() * num_vecs); make 903 src/CodeGen_ARM.cpp Expr slice_ramp = Ramp::make(slice_base, ramp->stride, intrin_lanes); make 961 src/CodeGen_ARM.cpp Expr absd = Call::make(UInt(narrow.bits(), narrow.lanes()), Call::absd, make 964 src/CodeGen_ARM.cpp absd = Cast::make(op->type, absd); make 773 src/CodeGen_C.cpp print_expr(Call::make(op->type, "max", {op->a, op->b}, Call::Extern)); make 777 src/CodeGen_C.cpp print_expr(Call::make(op->type, "min", {op->a, op->b}, Call::Extern)); make 1198 src/CodeGen_C.cpp Expr new_var = Variable::make(op->value.type(), id_value); make 1228 src/CodeGen_C.cpp Expr new_var = Variable::make(op->value.type(), id_value); make 1360 src/CodeGen_C.cpp Expr conditional_size = Select::make(op->condition, make 1462 src/CodeGen_C.cpp Expr e = Select::make(alpha > 4.0f, print_when(x < 1, 3), 2); make 1463 src/CodeGen_C.cpp Stmt s = Store::make("buf", e, x, Parameter(), const_true()); make 1464 src/CodeGen_C.cpp s = LetStmt::make("x", beta+1, s); make 1465 src/CodeGen_C.cpp s = Block::make(s, Free::make("tmp.stack")); make 1466 src/CodeGen_C.cpp s = Allocate::make("tmp.stack", Int(32), {127}, const_true(), s); make 1467 src/CodeGen_C.cpp s = Block::make(s, Free::make("tmp.heap")); make 1468 src/CodeGen_C.cpp s = Allocate::make("tmp.heap", Int(32), {43, beta}, const_true(), s); make 1469 src/CodeGen_C.cpp Expr buf = Variable::make(Handle(), "buf.buffer"); make 1470 src/CodeGen_C.cpp s = LetStmt::make("buf", Call::make(Handle(), Call::buffer_get_host, {buf}, Call::Extern), s); make 78 src/CodeGen_GPU_Host.cpp shared_mem_size = Let::make(op->name, op->value, shared_mem_size); make 265 src/CodeGen_GPU_Host.cpp gpu_num_padded_attributes = codegen(Variable::make(Int(32), "glsl.num_padded_attributes")); make 266 src/CodeGen_GPU_Host.cpp gpu_num_coords_dim0 = codegen(Variable::make(Int(32), "glsl.num_coords_dim0")); make 267 src/CodeGen_GPU_Host.cpp gpu_num_coords_dim1 = codegen(Variable::make(Int(32), "glsl.num_coords_dim1")); make 271 src/CodeGen_GPU_Host.cpp gpu_vertex_buffer = codegen(Variable::make(type_of<float *>(), "glsl.vertex_buffer")); make 361 src/CodeGen_GPU_Host.cpp Expr buf = Variable::make(type_of<buffer_t *>(), name + ".buffer"); make 362 src/CodeGen_GPU_Host.cpp Expr get_dev = Call::make(UInt(64), Call::buffer_get_device, {buf}, Call::Extern); make 125 src/CodeGen_Hexagon.cpp Expr hvx_lock = Call::make(Int(32), "halide_qurt_hvx_lock", {hvx_mode}, Call::Extern); make 127 src/CodeGen_Hexagon.cpp Expr hvx_lock_result_var = Variable::make(Int(32), hvx_lock_result_name); make 128 src/CodeGen_Hexagon.cpp Stmt check_hvx_lock = LetStmt::make(hvx_lock_result_name, hvx_lock, make 129 src/CodeGen_Hexagon.cpp AssertStmt::make(EQ::make(hvx_lock_result_var, 0), hvx_lock_result_var)); make 132 src/CodeGen_Hexagon.cpp Expr hvx_unlock = Call::make(Int(32), Call::register_destructor, make 135 src/CodeGen_Hexagon.cpp stmt = Block::make(Evaluate::make(hvx_unlock), stmt); make 136 src/CodeGen_Hexagon.cpp stmt = Block::make(check_hvx_lock, stmt); make 162 src/CodeGen_Hexagon.cpp Expr condition = Shuffle::make({predicate}, {0}); make 164 src/CodeGen_Hexagon.cpp condition = condition || Shuffle::make({predicate}, {i}); make 166 src/CodeGen_Hexagon.cpp predicate = Broadcast::make(condition, predicate.type().lanes()); make 168 src/CodeGen_Hexagon.cpp expr = Load::make(op->type, op->name, index, op->image, op->param, predicate); make 1382 src/CodeGen_Hexagon.cpp Expr p_wide = Call::make(wide_ty, "halide.hexagon.mpy" + type_suffix(a, b), make 1387 src/CodeGen_Hexagon.cpp Expr p = Call::make(ty, "halide.hexagon.trunclo" + type_suffix(p_wide, false), make 1405 src/CodeGen_Hexagon.cpp return Call::make(ty, "halide.hexagon.avg" + type_suffix(a, b), make 1506 src/CodeGen_Hexagon.cpp Expr equiv = -Cast::make(op->type, op->args[0]); make 1514 src/CodeGen_Hexagon.cpp value = codegen(Cast::make(Bool(), Shuffle::make_extract_element(op->args[0], *index))); make 1576 src/CodeGen_Hexagon.cpp Call::make(op->type, Call::select_mask, {op->a > op->b, op->a, op->b}, Call::PureIntrinsic); make 1593 src/CodeGen_Hexagon.cpp Call::make(op->type, Call::select_mask, {op->a > op->b, op->b, op->a}, Call::PureIntrinsic); make 1607 src/CodeGen_Hexagon.cpp value = codegen(Call::make(op->type, Call::if_then_else, make 1637 src/CodeGen_Hexagon.cpp Expr ge = Not::make(GT::make(op->b, op->a)); make 1647 src/CodeGen_Hexagon.cpp Expr le = Not::make(GT::make(op->a, op->b)); make 1657 src/CodeGen_Hexagon.cpp Expr lt = GT::make(op->b, op->a); make 1666 src/CodeGen_Hexagon.cpp Expr eq = Not::make(EQ::make(op->a, op->b)); make 221 src/CodeGen_Internal.cpp Expr q = Call::make(a.type(), Call::div_round_to_zero, {a, b}, Call::PureIntrinsic); make 252 src/CodeGen_Internal.cpp Expr r = Call::make(a.type(), Call::mod_round_to_zero, {a, b}, Call::PureIntrinsic); make 285 src/CodeGen_Internal.cpp Expr unpredicated_load = Load::make(op->type, op->name, index, op->image, op->param, make 287 src/CodeGen_Internal.cpp expr = Call::make(op->type, Call::if_then_else, {scalar_pred->value, unpredicated_load, make_zero(op->type)}, make 291 src/CodeGen_Internal.cpp Expr index_var = Variable::make(index.type(), index_name); make 293 src/CodeGen_Internal.cpp Expr predicate_var = Variable::make(predicate.type(), predicate_name); make 298 src/CodeGen_Internal.cpp Expr idx_i = Shuffle::make({index_var}, {i}); make 299 src/CodeGen_Internal.cpp Expr pred_i = Shuffle::make({predicate_var}, {i}); make 300 src/CodeGen_Internal.cpp Expr unpredicated_load = Load::make(op->type.element_of(), op->name, idx_i, op->image, op->param, make 302 src/CodeGen_Internal.cpp lanes.push_back(Call::make(op->type.element_of(), Call::if_then_else, {pred_i, unpredicated_load, make 306 src/CodeGen_Internal.cpp expr = Shuffle::make(lanes, ramp); make 307 src/CodeGen_Internal.cpp expr = Let::make(predicate_name, predicate, expr); make 308 src/CodeGen_Internal.cpp expr = Let::make(index_name, index, expr); make 323 src/CodeGen_Internal.cpp Stmt unpredicated_store = Store::make(op->name, value, index, op->param, const_true(value.type().lanes())); make 324 src/CodeGen_Internal.cpp stmt = IfThenElse::make(scalar_pred->value, unpredicated_store); make 327 src/CodeGen_Internal.cpp Expr value_var = Variable::make(value.type(), value_name); make 329 src/CodeGen_Internal.cpp Expr index_var = Variable::make(index.type(), index_name); make 331 src/CodeGen_Internal.cpp Expr predicate_var = Variable::make(predicate.type(), predicate_name); make 335 src/CodeGen_Internal.cpp Expr pred_i = Shuffle::make({predicate_var}, {i}); make 336 src/CodeGen_Internal.cpp Expr value_i = Shuffle::make({value_var}, {i}); make 337 src/CodeGen_Internal.cpp Expr index_i = Shuffle::make({index_var}, {i}); make 338 src/CodeGen_Internal.cpp Stmt lane = IfThenElse::make(pred_i, Store::make(op->name, value_i, index_i, op->param, const_true())); make 341 src/CodeGen_Internal.cpp stmt = Block::make(lanes); make 342 src/CodeGen_Internal.cpp stmt = LetStmt::make(predicate_name, predicate, stmt); make 343 src/CodeGen_Internal.cpp stmt = LetStmt::make(value_name, value, stmt); make 344 src/CodeGen_Internal.cpp stmt = LetStmt::make(index_name, index, stmt); make 183 src/CodeGen_LLVM.cpp wild_i8x8(Variable::make(Int(8, 8), "*")), make 184 src/CodeGen_LLVM.cpp wild_i16x4(Variable::make(Int(16, 4), "*")), make 185 src/CodeGen_LLVM.cpp wild_i32x2(Variable::make(Int(32, 2), "*")), make 187 src/CodeGen_LLVM.cpp wild_u8x8(Variable::make(UInt(8, 8), "*")), make 188 src/CodeGen_LLVM.cpp wild_u16x4(Variable::make(UInt(16, 4), "*")), make 189 src/CodeGen_LLVM.cpp wild_u32x2(Variable::make(UInt(32, 2), "*")), make 191 src/CodeGen_LLVM.cpp wild_i8x16(Variable::make(Int(8, 16), "*")), make 192 src/CodeGen_LLVM.cpp wild_i16x8(Variable::make(Int(16, 8), "*")), make 193 src/CodeGen_LLVM.cpp wild_i32x4(Variable::make(Int(32, 4), "*")), make 194 src/CodeGen_LLVM.cpp wild_i64x2(Variable::make(Int(64, 2), "*")), make 196 src/CodeGen_LLVM.cpp wild_u8x16(Variable::make(UInt(8, 16), "*")), make 197 src/CodeGen_LLVM.cpp wild_u16x8(Variable::make(UInt(16, 8), "*")), make 198 src/CodeGen_LLVM.cpp wild_u32x4(Variable::make(UInt(32, 4), "*")), make 199 src/CodeGen_LLVM.cpp wild_u64x2(Variable::make(UInt(64, 2), "*")), make 201 src/CodeGen_LLVM.cpp wild_i8x32(Variable::make(Int(8, 32), "*")), make 202 src/CodeGen_LLVM.cpp wild_i16x16(Variable::make(Int(16, 16), "*")), make 203 src/CodeGen_LLVM.cpp wild_i32x8(Variable::make(Int(32, 8), "*")), make 204 src/CodeGen_LLVM.cpp wild_i64x4(Variable::make(Int(64, 4), "*")), make 206 src/CodeGen_LLVM.cpp wild_u8x32(Variable::make(UInt(8, 32), "*")), make 207 src/CodeGen_LLVM.cpp wild_u16x16(Variable::make(UInt(16, 16), "*")), make 208 src/CodeGen_LLVM.cpp wild_u32x8(Variable::make(UInt(32, 8), "*")), make 209 src/CodeGen_LLVM.cpp wild_u64x4(Variable::make(UInt(64, 4), "*")), make 211 src/CodeGen_LLVM.cpp wild_f32x2(Variable::make(Float(32, 2), "*")), make 213 src/CodeGen_LLVM.cpp wild_f32x4(Variable::make(Float(32, 4), "*")), make 214 src/CodeGen_LLVM.cpp wild_f64x2(Variable::make(Float(64, 2), "*")), make 216 src/CodeGen_LLVM.cpp wild_f32x8(Variable::make(Float(32, 8), "*")), make 217 src/CodeGen_LLVM.cpp wild_f64x4(Variable::make(Float(64, 4), "*")), make 219 src/CodeGen_LLVM.cpp wild_u1x_ (Variable::make(UInt(1, 0), "*")), make 220 src/CodeGen_LLVM.cpp wild_i8x_ (Variable::make(Int(8, 0), "*")), make 221 src/CodeGen_LLVM.cpp wild_u8x_ (Variable::make(UInt(8, 0), "*")), make 222 src/CodeGen_LLVM.cpp wild_i16x_(Variable::make(Int(16, 0), "*")), make 223 src/CodeGen_LLVM.cpp wild_u16x_(Variable::make(UInt(16, 0), "*")), make 224 src/CodeGen_LLVM.cpp wild_i32x_(Variable::make(Int(32, 0), "*")), make 225 src/CodeGen_LLVM.cpp wild_u32x_(Variable::make(UInt(32, 0), "*")), make 226 src/CodeGen_LLVM.cpp wild_i64x_(Variable::make(Int(64, 0), "*")), make 227 src/CodeGen_LLVM.cpp wild_u64x_(Variable::make(UInt(64, 0), "*")), make 228 src/CodeGen_LLVM.cpp wild_f32x_(Variable::make(Float(32, 0), "*")), make 229 src/CodeGen_LLVM.cpp wild_f64x_(Variable::make(Float(64, 0), "*")), make 1345 src/CodeGen_LLVM.cpp Expr a = Variable::make(op->a.type(), a_name); make 1346 src/CodeGen_LLVM.cpp Expr b = Variable::make(op->b.type(), b_name); make 1347 src/CodeGen_LLVM.cpp value = codegen(Let::make(a_name, op->a, make 1348 src/CodeGen_LLVM.cpp Let::make(b_name, op->b, make 1355 src/CodeGen_LLVM.cpp Expr a = Variable::make(op->a.type(), a_name); make 1356 src/CodeGen_LLVM.cpp Expr b = Variable::make(op->b.type(), b_name); make 1357 src/CodeGen_LLVM.cpp value = codegen(Let::make(a_name, op->a, make 1358 src/CodeGen_LLVM.cpp Let::make(b_name, op->b, make 1473 src/CodeGen_LLVM.cpp return Add::make(promote_64(a->a), promote_64(a->b)); make 1475 src/CodeGen_LLVM.cpp return Sub::make(promote_64(s->a), promote_64(s->b)); make 1477 src/CodeGen_LLVM.cpp return Mul::make(promote_64(m->a), promote_64(m->b)); make 1479 src/CodeGen_LLVM.cpp return Min::make(promote_64(m->a), promote_64(m->b)); make 1481 src/CodeGen_LLVM.cpp return Max::make(promote_64(m->a), promote_64(m->b)); make 1618 src/CodeGen_LLVM.cpp codegen(reinterpret(op->type, Load::make(UInt(64, op->type.lanes()), op->name, make 1674 src/CodeGen_LLVM.cpp Expr ramp_a = Ramp::make(base_a, stride_a, ramp->lanes); make 1675 src/CodeGen_LLVM.cpp Expr ramp_b = Ramp::make(base_b, stride_b, ramp->lanes); make 1676 src/CodeGen_LLVM.cpp Expr load_a = Load::make(op->type, op->name, ramp_a, op->image, op->param, op->predicate); make 1677 src/CodeGen_LLVM.cpp Expr load_b = Load::make(op->type, op->name, ramp_b, op->image, op->param, op->predicate); make 1695 src/CodeGen_LLVM.cpp Expr flipped_index = Ramp::make(flipped_base, flipped_stride, ramp->lanes); make 1696 src/CodeGen_LLVM.cpp Expr flipped_load = Load::make(op->type, op->name, flipped_index, op->image, op->param, op->predicate); make 1756 src/CodeGen_LLVM.cpp Expr broadcast = Broadcast::make(op->base, op->lanes); make 1757 src/CodeGen_LLVM.cpp Expr ramp = Ramp::make(make_zero(op->base.type()), op->stride, op->lanes); make 1926 src/CodeGen_LLVM.cpp Expr slice_index = slice_lanes == 1 ? slice_base : Ramp::make(slice_base, slice_stride, slice_lanes); make 2013 src/CodeGen_LLVM.cpp Expr slice_index = slice_lanes == 1 ? slice_base : Ramp::make(slice_base, slice_stride, slice_lanes); make 2052 src/CodeGen_LLVM.cpp Expr flipped_index = Ramp::make(flipped_base, flipped_stride, ramp->lanes); make 2053 src/CodeGen_LLVM.cpp Expr flipped_load = Load::make(op->type, op->name, flipped_index, op->image, make 2059 src/CodeGen_LLVM.cpp Expr load_expr = Load::make(op->type, op->name, op->index, op->image, make 2062 src/CodeGen_LLVM.cpp Expr pred_load = Call::make(load_expr.type(), make 2173 src/CodeGen_LLVM.cpp codegen(Call::make(op->type, name, op->args, Call::Extern)); make 2177 src/CodeGen_LLVM.cpp Expr x = Variable::make(op->args[0].type(), x_name); make 2178 src/CodeGen_LLVM.cpp value = codegen(Let::make(x_name, op->args[0], select(x >= 0, x, -x))); make 2203 src/CodeGen_LLVM.cpp codegen(Call::make(op->type, name, op->args, Call::Extern)); make 2208 src/CodeGen_LLVM.cpp Expr a_var = Variable::make(op->args[0].type(), a_name); make 2209 src/CodeGen_LLVM.cpp Expr b_var = Variable::make(op->args[1].type(), b_name); make 2210 src/CodeGen_LLVM.cpp codegen(Let::make(a_name, op->args[0], make 2211 src/CodeGen_LLVM.cpp Let::make(b_name, op->args[1], make 2212 src/CodeGen_LLVM.cpp Select::make(a_var < b_var, b_var - a_var, a_var - b_var)))); make 2403 src/CodeGen_LLVM.cpp codegen(StringImm::make("true")), make 2404 src/CodeGen_LLVM.cpp codegen(StringImm::make("false")))); make 2407 src/CodeGen_LLVM.cpp call_args.push_back(codegen(Cast::make(Int(64), op->args[i]))); make 2411 src/CodeGen_LLVM.cpp call_args.push_back(codegen(Cast::make(UInt(64), op->args[i]))); make 2415 src/CodeGen_LLVM.cpp call_args.push_back(codegen(Cast::make(Float(64), op->args[i]))); make 3080 src/CodeGen_LLVM.cpp codegen(Store::make(op->name, v, op->index, op->param, op->predicate)); make 3099 src/CodeGen_LLVM.cpp Stmt s = Store::make(op->name, op->value, let->body, op->param, op->predicate); make 3100 src/CodeGen_LLVM.cpp codegen(LetStmt::make(let->name, let->value, s)); make 3136 src/CodeGen_LLVM.cpp Expr slice_index = slice_lanes == 1 ? slice_base : Ramp::make(slice_base, slice_stride, slice_lanes); make 185 src/CodeGen_OpenCL_Dev.cpp Expr equiv = -Cast::make(op->type, op->args[0]); make 190 src/CodeGen_OpenCL_Dev.cpp Expr equiv = Cast::make(op->type, op->args[0]); make 169 src/CodeGen_OpenGLCompute_Dev.cpp rhs << ", " << print_expr(Add::make(op->base, Mul::make(i, op->stride))); make 78 src/CodeGen_OpenGL_Dev.cpp new_args[i] = Cast::make(float_type, args[i]); make 83 src/CodeGen_OpenGL_Dev.cpp Expr val = Call::make(float_type, func, new_args, Call::Extern); make 84 src/CodeGen_OpenGL_Dev.cpp return simplify(Cast::make(result_type, val)); make 181 src/CodeGen_OpenGL_Dev.cpp Expr val = Div::make(Cast::make(float_type, op->a), Cast::make(float_type, op->b)); make 244 src/CodeGen_OpenGL_Dev.cpp print_expr(Call::make(op->type, "equal", {op->a, op->b}, Call::Extern)); make 252 src/CodeGen_OpenGL_Dev.cpp print_expr(Call::make(op->type, "notEqual", {op->a, op->b}, Call::Extern)); make 260 src/CodeGen_OpenGL_Dev.cpp print_expr(Call::make(op->type, "lessThan", {op->a, op->b}, Call::Extern)); make 268 src/CodeGen_OpenGL_Dev.cpp print_expr(Call::make(op->type, "lessThanEqual", {op->a, op->b}, Call::Extern)); make 276 src/CodeGen_OpenGL_Dev.cpp print_expr(Call::make(op->type, "greaterThan", {op->a, op->b}, Call::Extern)); make 284 src/CodeGen_OpenGL_Dev.cpp print_expr(Call::make(op->type, "greaterThanEqual", {op->a, op->b}, Call::Extern)); make 422 src/CodeGen_OpenGL_Dev.cpp result[i] = Select::make(cond, true_value, false_value); make 480 src/CodeGen_OpenGL_Dev.cpp Expr w = Variable::make(Int(32), "*"); make 706 src/CodeGen_OpenGL_Dev.cpp weight = Div::make(Cast::make(Float(32), weight), make 707 src/CodeGen_OpenGL_Dev.cpp Cast::make(Float(32), weight.type().max())); make 720 src/CodeGen_OpenGL_Dev.cpp e = Cast::make(op->type, floor(e + 0.5f)); make 809 src/CodeGen_OpenGL_Dev.cpp rhs << ", " << print_expr(Add::make(op->base, Mul::make(i, op->stride))); make 983 src/CodeGen_OpenGL_Dev.cpp Evaluate::make(e).accept(&cg); make 1007 src/CodeGen_OpenGL_Dev.cpp check(cast<float>(Variable::make(UInt(8), "x") * 1.0f), make 1010 src/CodeGen_OpenGL_Dev.cpp check(cast<uint8_t>(Variable::make(Float(32), "x")), make 1013 src/CodeGen_OpenGL_Dev.cpp check(Min::make(Expr(1), Expr(5)), make 1017 src/CodeGen_OpenGL_Dev.cpp check(Max::make(Expr(1), Expr(5)), make 1021 src/CodeGen_OpenGL_Dev.cpp check(Max::make(Broadcast::make(1, 4), Broadcast::make(5, 4)), make 1027 src/CodeGen_OpenGL_Dev.cpp check(Variable::make(Int(32), "x") / Expr(3), make 1032 src/CodeGen_OpenGL_Dev.cpp check(Variable::make(Int(32, 4), "x") / Variable::make(Int(32, 4), "y"), make 1038 src/CodeGen_OpenGL_Dev.cpp check(Variable::make(Float(32, 4), "x") / Variable::make(Float(32, 4), "y"), make 1058 src/CodeGen_OpenGL_Dev.cpp check(lerp(Variable::make(Float(32, 4), "x"), Variable::make(Float(32, 4), "y"), Broadcast::make(0.25f, 4)), make 1066 src/CodeGen_OpenGL_Dev.cpp check(Call::make(Float(32, 4), "sin_f32", {Broadcast::make(1.f, 4)}, Internal::Call::Extern), make 1078 src/CodeGen_OpenGL_Dev.cpp check(Variable::make(Int(32), "x") / Variable::make(Int(32), "y"), make 1086 src/CodeGen_OpenGL_Dev.cpp check(Select::make(EQ::make(Variable::make(Float(32), "x"), 1.0f), make 1087 src/CodeGen_OpenGL_Dev.cpp Broadcast::make(1.f, 4), make 1088 src/CodeGen_OpenGL_Dev.cpp Broadcast::make(2.f, 4)), make 1101 src/CodeGen_OpenGL_Dev.cpp check(Select::make(EQ::make(Ramp::make(-1, 1, 4), Broadcast::make(0, 4)), make 1102 src/CodeGen_OpenGL_Dev.cpp Broadcast::make(1.f, 4), make 1103 src/CodeGen_OpenGL_Dev.cpp Broadcast::make(2.f, 4)), make 1107 src/CodeGen_OpenGL_Dev.cpp Expr load4 = Call::make(Float(32, 4), Call::glsl_texture_load, make 1110 src/CodeGen_OpenGL_Dev.cpp Broadcast::make(0, 4), make 1111 src/CodeGen_OpenGL_Dev.cpp Broadcast::make(0, 4), make 1112 src/CodeGen_OpenGL_Dev.cpp Ramp::make(0, 1, 4)}, make 172 src/CodeGen_PTX_Dev.cpp Expr simt_idx = Call::make(Int(32), simt_intrinsic(loop->name), std::vector<Expr>(), Call::Extern); make 223 src/CodeGen_PTX_Dev.cpp Expr trap = Call::make(Int(32), "halide_ptx_trap", {}, Call::Extern); make 224 src/CodeGen_PTX_Dev.cpp codegen(IfThenElse::make(!op->condition, Evaluate::make(trap))); make 67 src/CodeGen_Posix.cpp Call::make(Int(32), "halide_error_buffer_allocation_too_large", make 215 src/CodeGen_Posix.cpp create_assertion(check, Call::make(Int(32), "halide_error_out_of_memory", make 69 src/CodeGen_X86.cpp codegen(Call::make(op->type, "pmaddwd", matches, Call::Extern)); make 85 src/CodeGen_X86.cpp codegen(Call::make(op->type, "pmaddwd", matches, Call::Extern)); make 13 src/DebugArguments.cpp stmts.push_back(Evaluate::make(print("Entering Pipeline " + func->name))); make 16 src/DebugArguments.cpp Expr scalar_var = Variable::make(arg.type, arg.name); make 17 src/DebugArguments.cpp Expr buffer_var = Variable::make(type_of<halide_buffer_t *>(), arg.name + ".buffer"); make 33 src/DebugArguments.cpp stmts.push_back(Evaluate::make(print(name.str(), value))); make 36 src/DebugArguments.cpp stmts.push_back(Evaluate::make(print("Exiting Pipeline " + func->name))); make 37 src/DebugArguments.cpp func->body = Block::make(stmts); make 70 src/DebugToFile.cpp Expr buf = Variable::make(Handle(), f.name() + ".buffer"); make 73 src/DebugToFile.cpp Expr call = Call::make(Int(32), Call::debug_to_file, args, Call::Intrinsic); make 75 src/DebugToFile.cpp Expr call_result_var = Variable::make(Int(32), call_result_name); make 76 src/DebugToFile.cpp Stmt body = AssertStmt::make(call_result_var == 0, make 77 src/DebugToFile.cpp Call::make(Int(32), "halide_error_debug_to_file_failed", make 80 src/DebugToFile.cpp body = LetStmt::make(call_result_name, call, body); make 81 src/DebugToFile.cpp body = Block::make(mutate(op->body), body); make 83 src/DebugToFile.cpp stmt = Realize::make(op->name, op->types, op->bounds, op->condition, body); make 119 src/DebugToFile.cpp Expr min = Variable::make(Int(32), out.name() + ".min." + dim); make 120 src/DebugToFile.cpp Expr extent = Variable::make(Int(32), out.name() + ".extent." + dim); make 123 src/DebugToFile.cpp s = Realize::make(out.name(), out.output_types(), output_bounds, const_true(), s); make 100 src/Deinterleave.cpp stmt = Evaluate::make(0); make 133 src/Deinterleave.cpp stmt = Block::make(first, rest); make 165 src/Deinterleave.cpp expr = Broadcast::make(op->value, new_lanes); make 174 src/Deinterleave.cpp expr = Load::make(t, op->name, mutate(op->index), op->image, op->param, mutate(op->predicate)); make 182 src/Deinterleave.cpp expr = Ramp::make(expr, op->stride * lane_stride, new_lanes); make 197 src/Deinterleave.cpp expr = Variable::make(t, op->name + ".even_lanes", op->image, op->param, op->reduction_domain); make 201 src/Deinterleave.cpp expr = Variable::make(t, op->name + ".odd_lanes", op->image, op->param, op->reduction_domain); make 205 src/Deinterleave.cpp expr = Variable::make(t, op->name + ".lanes_0_of_3", op->image, op->param, op->reduction_domain); make 209 src/Deinterleave.cpp expr = Variable::make(t, op->name + ".lanes_1_of_3", op->image, op->param, op->reduction_domain); make 213 src/Deinterleave.cpp expr = Variable::make(t, op->name + ".lanes_2_of_3", op->image, op->param, op->reduction_domain); make 221 src/Deinterleave.cpp expr = Shuffle::make({op}, indices); make 231 src/Deinterleave.cpp expr = Cast::make(t, mutate(op->value)); make 248 src/Deinterleave.cpp expr = Shuffle::make({op}, indices); make 263 src/Deinterleave.cpp expr = Call::make(t, op->name, args, op->call_type, make 273 src/Deinterleave.cpp Expr new_var = Variable::make(new_type, new_name); make 279 src/Deinterleave.cpp expr = Let::make(new_name, new_value, body); make 282 src/Deinterleave.cpp expr = Let::make(op->name, op->value, expr); make 307 src/Deinterleave.cpp expr = Shuffle::make({op}, indices); make 316 src/Deinterleave.cpp expr = Shuffle::make({op}, indices); make 432 src/Deinterleave.cpp result = T::make(op->name, value, body); make 438 src/Deinterleave.cpp result = T::make(op->name + ".even_lanes", extract_even_lanes(value, vector_lets), result); make 439 src/Deinterleave.cpp result = T::make(op->name + ".odd_lanes", extract_odd_lanes(value, vector_lets), result); make 442 src/Deinterleave.cpp result = T::make(op->name + ".lanes_0_of_3", extract_mod3_lanes(value, 0, vector_lets), result); make 443 src/Deinterleave.cpp result = T::make(op->name + ".lanes_1_of_3", extract_mod3_lanes(value, 1, vector_lets), result); make 444 src/Deinterleave.cpp result = T::make(op->name + ".lanes_2_of_3", extract_mod3_lanes(value, 2, vector_lets), result); make 503 src/Deinterleave.cpp expr = Load::make(op->type, op->name, idx, op->image, op->param, predicate); make 509 src/Deinterleave.cpp expr = Load::make(op->type, op->name, idx, op->image, op->param, predicate); make 514 src/Deinterleave.cpp expr = Load::make(op->type, op->name, idx, op->image, op->param, predicate); make 516 src/Deinterleave.cpp expr = Load::make(op->type, op->name, idx, op->image, op->param, predicate); make 547 src/Deinterleave.cpp stmt = Store::make(op->name, value, idx, op->param, predicate); make 677 src/Deinterleave.cpp args[j] = Load::make(t, load_name, stores[i].as<Store>()->index, make 690 src/Deinterleave.cpp Expr index = Ramp::make(base, make_one(base.type()), t.lanes()); make 693 src/Deinterleave.cpp Stmt new_store = Store::make(store->name, value, index, store->param, predicate); make 697 src/Deinterleave.cpp stmt = Block::make(new_store, mutate(rest)); make 702 src/Deinterleave.cpp stmt = LetStmt::make(let->name, let->value, stmt); make 713 src/Deinterleave.cpp stmt = Block::make(mutate(op->first), mutate(op->rest)); make 739 src/Deinterleave.cpp Expr x = Variable::make(Int(32), "x"); make 740 src/Deinterleave.cpp Expr ramp = Ramp::make(x + 4, 3, 8); make 741 src/Deinterleave.cpp Expr ramp_a = Ramp::make(x + 4, 6, 4); make 742 src/Deinterleave.cpp Expr ramp_b = Ramp::make(x + 7, 6, 4); make 743 src/Deinterleave.cpp Expr broadcast = Broadcast::make(x + 4, 16); make 744 src/Deinterleave.cpp Expr broadcast_a = Broadcast::make(x + 4, 8); make 750 src/Deinterleave.cpp check(Load::make(ramp.type(), "buf", ramp, Buffer<>(), Parameter(), const_true(ramp.type().lanes())), make 751 src/Deinterleave.cpp Load::make(ramp_a.type(), "buf", ramp_a, Buffer<>(), Parameter(), const_true(ramp_a.type().lanes())), make 752 src/Deinterleave.cpp Load::make(ramp_b.type(), "buf", ramp_b, Buffer<>(), Parameter(), const_true(ramp_b.type().lanes()))); make 101 src/EarlyFree.cpp Stmt free = Free::make(func); make 103 src/EarlyFree.cpp Expr buf = Variable::make(Handle(), func + ".buffer"); make 105 src/EarlyFree.cpp free = Block::make({device_free, free}); make 127 src/EarlyFree.cpp return Block::make(s, make_free(func, inject_device_free)); make 141 src/EarlyFree.cpp stmt = Block::make(new_first, new_rest); make 164 src/EarlyFree.cpp stmt = Allocate::make(alloc->name, alloc->type, alloc->extents, alloc->condition, make 165 src/EarlyFree.cpp Block::make(alloc->body, make_free(alloc->name, last_use.found_device_malloc)), make 17 src/EliminateBoolVectors.cpp expr = Variable::make(lets.get(op->name), op->name); make 37 src/EliminateBoolVectors.cpp a = Call::make(t, Call::cast_mask, {a}, Call::PureIntrinsic); make 40 src/EliminateBoolVectors.cpp b = Call::make(t, Call::cast_mask, {b}, Call::PureIntrinsic); make 45 src/EliminateBoolVectors.cpp expr = T::make(a, b); make 53 src/EliminateBoolVectors.cpp expr = Call::make(t.with_code(Type::Int), Call::bool_to_mask, {expr}, Call::PureIntrinsic); make 75 src/EliminateBoolVectors.cpp a = Call::make(t, Call::cast_mask, {a}, Call::PureIntrinsic); make 78 src/EliminateBoolVectors.cpp b = Call::make(t, Call::cast_mask, {b}, Call::PureIntrinsic); make 81 src/EliminateBoolVectors.cpp expr = Call::make(t, bitwise_op, {a, b}, Call::PureIntrinsic); make 83 src/EliminateBoolVectors.cpp expr = T::make(a, b); make 101 src/EliminateBoolVectors.cpp expr = Call::make(a.type(), Call::bitwise_not, {a}, Call::PureIntrinsic); make 103 src/EliminateBoolVectors.cpp expr = Not::make(a); make 112 src/EliminateBoolVectors.cpp expr = mutate(Select::make(op->value, make 128 src/EliminateBoolVectors.cpp value = Select::make(value, make 138 src/EliminateBoolVectors.cpp stmt = Store::make(op->name, value, index, op->param, predicate); make 157 src/EliminateBoolVectors.cpp cond = Call::make(cond_ty, Call::cast_mask, {cond}, Call::PureIntrinsic); make 160 src/EliminateBoolVectors.cpp expr = Call::make(true_value.type(), Call::select_mask, {cond, true_value, false_value}, Call::PureIntrinsic); make 164 src/EliminateBoolVectors.cpp expr = Select::make(cond, true_value, false_value); make 173 src/EliminateBoolVectors.cpp expr = Broadcast::make(Call::make(Int(8), Call::bool_to_mask, {value}, Call::PureIntrinsic), op->lanes); make 175 src/EliminateBoolVectors.cpp expr = Broadcast::make(value, op->lanes); make 188 src/EliminateBoolVectors.cpp expr = Call::make(Bool(), Call::extract_mask_element, {Shuffle::make_concat(op->vectors), op->indices[0]}, Call::PureIntrinsic); make 210 src/EliminateBoolVectors.cpp return LetType::make(op->name, value, body); make 173 src/Expr.h static const IntImm *make(Type t, int64_t value) { make 197 src/Expr.h static const UIntImm *make(Type t, uint64_t value) { make 220 src/Expr.h static const FloatImm *make(Type t, double value) { make 249 src/Expr.h static const StringImm *make(const std::string &val) { make 274 src/Expr.h EXPORT explicit Expr(int8_t x) : IRHandle(Internal::IntImm::make(Int(8), x)) {} make 275 src/Expr.h EXPORT explicit Expr(int16_t x) : IRHandle(Internal::IntImm::make(Int(16), x)) {} make 276 src/Expr.h EXPORT Expr(int32_t x) : IRHandle(Internal::IntImm::make(Int(32), x)) {} make 277 src/Expr.h EXPORT explicit Expr(int64_t x) : IRHandle(Internal::IntImm::make(Int(64), x)) {} make 278 src/Expr.h EXPORT explicit Expr(uint8_t x) : IRHandle(Internal::UIntImm::make(UInt(8), x)) {} make 279 src/Expr.h EXPORT explicit Expr(uint16_t x) : IRHandle(Internal::UIntImm::make(UInt(16), x)) {} make 280 src/Expr.h EXPORT explicit Expr(uint32_t x) : IRHandle(Internal::UIntImm::make(UInt(32), x)) {} make 281 src/Expr.h EXPORT explicit Expr(uint64_t x) : IRHandle(Internal::UIntImm::make(UInt(64), x)) {} make 282 src/Expr.h EXPORT Expr(float16_t x) : IRHandle(Internal::FloatImm::make(Float(16), (double)x)) {} make 283 src/Expr.h EXPORT Expr(float x) : IRHandle(Internal::FloatImm::make(Float(32), x)) {} make 284 src/Expr.h EXPORT explicit Expr(double x) : IRHandle(Internal::FloatImm::make(Float(64), x)) {} make 288 src/Expr.h EXPORT Expr(const std::string &s) : IRHandle(Internal::StringImm::make(s)) {} make 20 src/Extern.h return Halide::Internal::Call::make(Halide::type_of<rt>(), #name, {a1}, Halide::Internal::Call::Extern); \ make 27 src/Extern.h return Halide::Internal::Call::make(Halide::type_of<rt>(), #name, {a1, a2}, Halide::Internal::Call::Extern); \ make 35 src/Extern.h return Halide::Internal::Call::make(Halide::type_of<rt>(), #name, {a1, a2, a3}, Halide::Internal::Call::Extern); \ make 44 src/Extern.h return Halide::Internal::Call::make(Halide::type_of<rt>(), #name, {a1, a2, a3, a4}, Halide::Internal::Call::Extern); \ make 54 src/Extern.h return Halide::Internal::Call::make(Halide::type_of<rt>(), #name, {a1, a2, a3, a4, a5}, Halide::Internal::Call::Extern); \ make 60 src/Extern.h return Halide::Internal::Call::make(Halide::type_of<rt>(), #name, {a1}, Halide::Internal::Call::PureExtern); \ make 67 src/Extern.h return Halide::Internal::Call::make(Halide::type_of<rt>(), #name, {a1, a2}, Halide::Internal::Call::PureExtern); \ make 75 src/Extern.h return Halide::Internal::Call::make(Halide::type_of<rt>(), #name, {a1, a2, a3}, Halide::Internal::Call::PureExtern); \ make 84 src/Extern.h return Halide::Internal::Call::make(Halide::type_of<rt>(), #name, {a1, a2, a3, a4}, Halide::Internal::Call::PureExtern); \ make 94 src/Extern.h return Halide::Internal::Call::make(Halide::type_of<rt>(), #name, {a1, a2, a3, a4, a5}, Halide::Internal::Call::PureExtern); \ make 374 src/Func.cpp expr = Call::make(substitute, args, c->value_index); make 870 src/Func.cpp Expr prev_val = Call::make(intm.output_types()[i], func_name, make 884 src/Func.cpp Expr prev_val = Call::make(intm.output_types()[0], func_name, make 2661 src/Func.cpp return Call::make(func, args); make 2728 src/Func.cpp return Internal::Call::make(func_ref.function(), args, idx); make 212 src/Function.cpp expr = Call::make(c->type, c->name, c->args, c->call_type, make 830 src/Function.cpp return Call::make(Int(32), contents->extern_function_name, args, call_type, contents); make 906 src/Function.cpp expr = Call::make(subs, c->args, c->value_index); make 52 src/FuseGPUThreadLoops.cpp stmt = Block::make(Block::make(first, barrier), rest); make 61 src/FuseGPUThreadLoops.cpp Evaluate::make(Call::make(Int(32), "halide_gpu_thread_barrier", make 77 src/FuseGPUThreadLoops.cpp block_extent[dim] = simplify(Max::make(extent, block_extent[dim])); make 92 src/FuseGPUThreadLoops.cpp Interval(Variable::make(Int(32), op->name + ".loop_min"), make 93 src/FuseGPUThreadLoops.cpp Variable::make(Int(32), op->name + ".loop_max"))); make 107 src/FuseGPUThreadLoops.cpp block_extent[i] = simplify(Let::make(op->name, op->value, block_extent[i])); make 147 src/FuseGPUThreadLoops.cpp s = For::make("." + name, 0, 1, ForType::GPUThread, device_api, s); make 165 src/FuseGPUThreadLoops.cpp stmt = Block::make(first, rest); make 205 src/FuseGPUThreadLoops.cpp Expr var = Variable::make(Int(32), "." + thread_names[dim]); make 212 src/FuseGPUThreadLoops.cpp stmt = IfThenElse::make(cond, body, Stmt()); make 289 src/FuseGPUThreadLoops.cpp scope.push(op->name, Interval(Variable::make(Int(32), op->name + ".loop_min"), make 290 src/FuseGPUThreadLoops.cpp Variable::make(Int(32), op->name + ".loop_max"))); make 306 src/FuseGPUThreadLoops.cpp stmt = For::make(op->name, mutate(op->min), mutate(op->extent), op->for_type, op->device_api, body); make 320 src/FuseGPUThreadLoops.cpp stmt = Block::make(first, rest); make 361 src/FuseGPUThreadLoops.cpp expr = Load::make(op->type, shared_mem_name + "_" + op->name, make 364 src/FuseGPUThreadLoops.cpp Expr base = Variable::make(Int(32), op->name + ".shared_offset"); make 365 src/FuseGPUThreadLoops.cpp expr = Load::make(op->type, shared_mem_name, base + index, make 381 src/FuseGPUThreadLoops.cpp stmt = Store::make(shared_mem_name + "_" + op->name, value, index, make 384 src/FuseGPUThreadLoops.cpp Expr base = Variable::make(Int(32), op->name + ".shared_offset"); make 385 src/FuseGPUThreadLoops.cpp stmt = Store::make(shared_mem_name, value, base + index, op->param, predicate); make 403 src/FuseGPUThreadLoops.cpp s.size = simplify(Let::make(op->name, op->value, s.size)); make 410 src/FuseGPUThreadLoops.cpp stmt = LetStmt::make(op->name, value, body); make 527 src/FuseGPUThreadLoops.cpp s = Allocate::make(shared_mem_name + "_" + alloc.name, make 553 src/FuseGPUThreadLoops.cpp Expr total_size = Variable::make(Int(32), "group_" + std::to_string(mem_allocs.size()-1) + ".shared_offset"); make 554 src/FuseGPUThreadLoops.cpp s = Allocate::make(shared_mem_name, UInt(8), {total_size}, const_true(), s); make 560 src/FuseGPUThreadLoops.cpp Expr group_offset = Variable::make(Int(32), "group_" + std::to_string(i) + ".shared_offset"); make 565 src/FuseGPUThreadLoops.cpp s = LetStmt::make(alloc.name + ".shared_offset", simplify(offset), s); make 570 src/FuseGPUThreadLoops.cpp offset = Variable::make(Int(32), "group_" + std::to_string(i-1) + ".shared_offset"); make 574 src/FuseGPUThreadLoops.cpp s = LetStmt::make("group_" + std::to_string(i) + ".shared_offset", simplify(offset), s); make 613 src/FuseGPUThreadLoops.cpp body = For::make("." + thread_names[i], 0, block_size.extent(i), ForType::GPUThread, op->device_api, body); make 618 src/FuseGPUThreadLoops.cpp body = For::make(".__thread_id_x", 0, 1, ForType::GPUThread, op->device_api, body); make 630 src/FuseGPUThreadLoops.cpp stmt = For::make(op->name, op->min, op->extent, op->for_type, op->device_api, body); make 696 src/FuseGPUThreadLoops.cpp Expr adjusted = Variable::make(Int(32), op->name) + op->min; make 698 src/FuseGPUThreadLoops.cpp stmt = For::make(op->name, 0, op->extent, op->for_type, op->device_api, body); make 21 src/FuzzFloatStores.cpp stmt = Store::make(op->name, value, op->index, op->param, op->predicate); make 170 src/Generator.cpp f(args) = Internal::Call::make(p, args_expr); make 1669 src/Generator.cpp Expr e = Internal::Variable::make(type(), array_name(i), parameters_[i]); make 579 src/HexagonOffload.cpp expr = Load::make(op->type, op->name, mutate(op->index), op->image, make 589 src/HexagonOffload.cpp stmt = Store::make(op->name, mutate(op->value), mutate(op->index), make 615 src/HexagonOffload.cpp return Let::make(name, state_var_ptr(name, type), make 616 src/HexagonOffload.cpp Load::make(type_of<void*>(), name, 0, make 625 src/HexagonOffload.cpp buf = Variable::make(type_of<halide_buffer_t *>(), storage.name() + ".buffer", storage); make 627 src/HexagonOffload.cpp return Call::make(Handle(), Call::buffer_get_host, {buf}, Call::Extern); make 643 src/HexagonOffload.cpp Expr buf = Variable::make(type_of<halide_buffer_t *>(), string(name) + ".buffer", code); make 644 src/HexagonOffload.cpp return Call::make(Handle(), Call::buffer_get_host, {buf}, Call::Extern); make 665 src/HexagonOffload.cpp Stmt body = For::make(loop->name, loop->min, loop->extent, loop->for_type, make 705 src/HexagonOffload.cpp Expr host_ptr = reinterpret<uint64_t>(Variable::make(Handle(), i.first)); make 706 src/HexagonOffload.cpp Expr error = Call::make(Int(32), "halide_error_unaligned_host_ptr", make 708 src/HexagonOffload.cpp body = Block::make(AssertStmt::make(host_ptr % alignment == 0, error), body); make 712 src/HexagonOffload.cpp Expr buf = Variable::make(Handle(), i.first + ".buffer"); make 713 src/HexagonOffload.cpp Expr host_ptr = Call::make(Handle(), "_halide_hexagon_buffer_get_host", {buf}, Call::Extern); make 714 src/HexagonOffload.cpp Expr device_ptr = Call::make(Handle(), "_halide_hexagon_buffer_get_device", {buf}, Call::Extern); make 715 src/HexagonOffload.cpp body = LetStmt::make(i.first + ".device", device_ptr, body); make 716 src/HexagonOffload.cpp body = LetStmt::make(i.first, host_ptr, body); make 743 src/HexagonOffload.cpp Expr buf = Variable::make(type_of<halide_buffer_t *>(), i.first + ".buffer"); make 744 src/HexagonOffload.cpp Expr device = Call::make(UInt(64), Call::buffer_get_device, {buf}, Call::Extern); make 745 src/HexagonOffload.cpp Expr host = Call::make(Handle(), Call::buffer_get_host, {buf}, Call::Extern); make 746 src/HexagonOffload.cpp Expr pseudo_buffer = Call::make(Handle(), Call::make_struct, {device, host}, Call::Intrinsic); make 759 src/HexagonOffload.cpp Expr arg = Variable::make(i.second, i.first); make 760 src/HexagonOffload.cpp Expr arg_ptr = Call::make(type_of<void *>(), Call::make_struct, {arg}, Call::Intrinsic); make 774 src/HexagonOffload.cpp params.push_back(Call::make(type_of<size_t*>(), Call::make_struct, arg_sizes, Call::Intrinsic)); make 775 src/HexagonOffload.cpp params.push_back(Call::make(type_of<void**>(), Call::make_struct, arg_ptrs, Call::Intrinsic)); make 776 src/HexagonOffload.cpp params.push_back(Call::make(type_of<int*>(), Call::make_struct, arg_flags, Call::Intrinsic)); make 813 src/HexagonOffload.cpp Expr buf_var = Variable::make(type_of<struct halide_buffer_t *>(), "hexagon_code.buffer"); make 814 src/HexagonOffload.cpp Expr code_size = Call::make(Int(32), Call::buffer_get_extent, { buf_var, 0 }, Call::Extern); make 815 src/HexagonOffload.cpp Expr code_ptr = Call::make(Handle(), Call::buffer_get_host, { buf_var }, Call::Extern); make 818 src/HexagonOffload.cpp s = Block::make(init_kernels, s); make 33 src/HexagonOptimize.cpp return Call::make(x.type(), fn, {x}, Call::PureExtern); make 44 src/HexagonOptimize.cpp return Call::make(x.type(), fn, {x}, Call::PureExtern); make 64 src/HexagonOptimize.cpp Expr bc(Expr x) { return Broadcast::make(x, 0); } make 77 src/HexagonOptimize.cpp expr = Cast::make(with_lanes(op->type), mutate(op->value)); make 85 src/HexagonOptimize.cpp expr = Variable::make(with_lanes(op->type), op->name); make 93 src/HexagonOptimize.cpp expr = Broadcast::make(op->value, lanes); make 153 src/HexagonOptimize.cpp Expr wild_u8 = Variable::make(UInt(8), "*"); make 154 src/HexagonOptimize.cpp Expr wild_u16 = Variable::make(UInt(16), "*"); make 155 src/HexagonOptimize.cpp Expr wild_u32 = Variable::make(UInt(32), "*"); make 156 src/HexagonOptimize.cpp Expr wild_u64 = Variable::make(UInt(64), "*"); make 157 src/HexagonOptimize.cpp Expr wild_i8 = Variable::make(Int(8), "*"); make 158 src/HexagonOptimize.cpp Expr wild_i16 = Variable::make(Int(16), "*"); make 159 src/HexagonOptimize.cpp Expr wild_i32 = Variable::make(Int(32), "*"); make 160 src/HexagonOptimize.cpp Expr wild_i64 = Variable::make(Int(64), "*"); make 162 src/HexagonOptimize.cpp Expr wild_u8x = Variable::make(Type(Type::UInt, 8, 0), "*"); make 163 src/HexagonOptimize.cpp Expr wild_u16x = Variable::make(Type(Type::UInt, 16, 0), "*"); make 164 src/HexagonOptimize.cpp Expr wild_u32x = Variable::make(Type(Type::UInt, 32, 0), "*"); make 165 src/HexagonOptimize.cpp Expr wild_u64x = Variable::make(Type(Type::UInt, 64, 0), "*"); make 166 src/HexagonOptimize.cpp Expr wild_i8x = Variable::make(Type(Type::Int, 8, 0), "*"); make 167 src/HexagonOptimize.cpp Expr wild_i16x = Variable::make(Type(Type::Int, 16, 0), "*"); make 168 src/HexagonOptimize.cpp Expr wild_i32x = Variable::make(Type(Type::Int, 32, 0), "*"); make 169 src/HexagonOptimize.cpp Expr wild_i64x = Variable::make(Type(Type::Int, 64, 0), "*"); make 241 src/HexagonOptimize.cpp x = Call::make(x.type(), p.intrin, matches, Call::PureExtern); make 260 src/HexagonOptimize.cpp return Mul::make(a, m->b); make 264 src/HexagonOptimize.cpp return Mul::make(m->a, b); make 279 src/HexagonOptimize.cpp Expr commuted = T::make(op->b, op->a); make 360 src/HexagonOptimize.cpp Expr call = Call::make(result_type, "halide.hexagon.add_2mpy" + suffix, {v0, v1, c0, c1}, Call::PureExtern); make 365 src/HexagonOptimize.cpp return Call::make(result_type, "halide.hexagon.add_2mpy" + suffix, {v01, c01}, Call::PureExtern); make 369 src/HexagonOptimize.cpp return Call::make(result_type, "halide.hexagon.add_4mpy" + suffix, {v01, c01}, Call::PureExtern); make 394 src/HexagonOptimize.cpp rest = rest.defined() ? Add::make(rest, op) : op; make 433 src/HexagonOptimize.cpp Expr add_b = Mul::make(simplify(-mul_b->a), mul_b->b); make 439 src/HexagonOptimize.cpp Expr add_b = Mul::make(mul_b->a, simplify(-mul_b->b)); make 457 src/HexagonOptimize.cpp rest = rest.defined() ? Add::make(rest, op) : op; make 503 src/HexagonOptimize.cpp new_expr = Call::make(op->type, "halide.hexagon.pack.vw", {new_expr}, Call::PureExtern); make 506 src/HexagonOptimize.cpp new_expr = Add::make(new_expr, rest); make 542 src/HexagonOptimize.cpp new_expr = Call::make(op->type, "halide.hexagon.pack.vw", {new_expr}, Call::PureExtern); make 545 src/HexagonOptimize.cpp new_expr = Add::make(new_expr, rest); make 590 src/HexagonOptimize.cpp new_expr = Add::make(new_expr, rest); make 713 src/HexagonOptimize.cpp expr = Call::make(op->type, i.first, {matches[0]}, Call::PureExtern) + 1; make 891 src/HexagonOptimize.cpp expr = mutate(Cast::make(dst_type, op->args[0])); make 1002 src/HexagonOptimize.cpp return Variable::make(var->type, var->name + ".deinterleaved"); make 1004 src/HexagonOptimize.cpp return Variable::make(var->type, var->name + ".weak_deinterleaved"); make 1011 src/HexagonOptimize.cpp return Let::make(let->name, let->value, remove_interleave(let->body)); make 1028 src/HexagonOptimize.cpp expr = T::make(a, b); make 1036 src/HexagonOptimize.cpp expr = T::make(a, b); make 1084 src/HexagonOptimize.cpp expr = native_interleave(Select::make(cond, true_value, false_value)); make 1088 src/HexagonOptimize.cpp expr = Select::make(cond, true_value, false_value); make 1133 src/HexagonOptimize.cpp result = LetType::make(op->name, value, body); make 1149 src/HexagonOptimize.cpp Expr interleaved = Variable::make(deinterleaved.type(), deinterleaved_name); make 1154 src/HexagonOptimize.cpp result = LetType::make(op->name, interleaved, result); make 1155 src/HexagonOptimize.cpp result = LetType::make(deinterleaved_name, deinterleaved, result); make 1158 src/HexagonOptimize.cpp result = LetType::make(deinterleaved_name, remove_interleave(value), result); make 1161 src/HexagonOptimize.cpp result = LetType::make(op->name, value, result); make 1175 src/HexagonOptimize.cpp expr = native_interleave(Let::make(let->name, let->value, remove_interleave(let->body))); make 1188 src/HexagonOptimize.cpp expr = native_interleave(Cast::make(op->type, value)); make 1190 src/HexagonOptimize.cpp expr = Cast::make(op->type, value); make 1248 src/HexagonOptimize.cpp expr = Call::make(op->type, Call::bool_to_mask, {arg}, Call::PureIntrinsic); make 1313 src/HexagonOptimize.cpp expr = Call::make(op->type, op->name, args, op->call_type, make 1325 src/HexagonOptimize.cpp expr = Call::make(op->type, deinterleaving_alts[op->name], args, op->call_type); make 1332 src/HexagonOptimize.cpp expr = Call::make(op->type, interleaving_alts[op->name], { arg }, op->call_type, make 1335 src/HexagonOptimize.cpp expr = Call::make(op->type, op->name, args, op->call_type, make 1372 src/HexagonOptimize.cpp stmt = Allocate::make(op->name, op->type, op->extents, condition, body, make 1418 src/HexagonOptimize.cpp stmt = Store::make(op->name, value, index, op->param, predicate); make 1478 src/HexagonOptimize.cpp expr = Call::make(op->type, i.second, args, Call::PureExtern); make 1584 src/HexagonOptimize.cpp Expr lut = Load::make(op->type.with_lanes(const_extent), op->name, make 1585 src/HexagonOptimize.cpp Ramp::make(base, 1, const_extent), make 1593 src/HexagonOptimize.cpp expr = Call::make(op->type, "dynamic_shuffle", {lut, index, 0, const_extent - 1}, Call::PureIntrinsic); make 1599 src/HexagonOptimize.cpp expr = Load::make(op->type, op->name, index, op->image, op->param, op->predicate); make 321 src/IR.cpp return ProducerConsumer::make(name, true, body); make 325 src/IR.cpp return ProducerConsumer::make(name, false, body); make 488 src/IR.cpp node->rest = Block::make(b->rest, rest); make 503 src/IR.cpp result = Block::make(stmts[i-1], result); make 533 src/IR.cpp return make(func.output_types()[(size_t)idx], func.name(), args, Halide, make 626 src/IR.cpp return make(vectors, indices); make 644 src/IR.cpp return make(vectors, indices); make 657 src/IR.cpp return make({vector}, indices); make 31 src/IR.h EXPORT static Expr make(Type t, const Expr &v); make 40 src/IR.h EXPORT static Expr make(const Expr &a, const Expr &b); make 49 src/IR.h EXPORT static Expr make(const Expr &a, const Expr &b); make 58 src/IR.h EXPORT static Expr make(const Expr &a, const Expr &b); make 67 src/IR.h EXPORT static Expr make(const Expr &a, const Expr &b); make 78 src/IR.h EXPORT static Expr make(const Expr &a, const Expr &b); make 87 src/IR.h EXPORT static Expr make(const Expr &a, const Expr &b); make 96 src/IR.h EXPORT static Expr make(const Expr &a, const Expr &b); make 105 src/IR.h EXPORT static Expr make(const Expr &a, const Expr &b); make 114 src/IR.h EXPORT static Expr make(const Expr &a, const Expr &b); make 123 src/IR.h EXPORT static Expr make(const Expr &a, const Expr &b); make 132 src/IR.h EXPORT static Expr make(const Expr &a, const Expr &b); make 141 src/IR.h EXPORT static Expr make(const Expr &a, const Expr &b); make 150 src/IR.h EXPORT static Expr make(const Expr &a, const Expr &b); make 159 src/IR.h EXPORT static Expr make(const Expr &a, const Expr &b); make 168 src/IR.h EXPORT static Expr make(const Expr &a, const Expr &b); make 177 src/IR.h EXPORT static Expr make(const Expr &a); make 188 src/IR.h EXPORT static Expr make(const Expr &condition, const Expr &true_value, const Expr &false_value); make 210 src/IR.h EXPORT static Expr make(Type type, const std::string &name, make 226 src/IR.h EXPORT static Expr make(const Expr &base, const Expr &stride, int lanes); make 238 src/IR.h EXPORT static Expr make(const Expr &value, int lanes); make 250 src/IR.h EXPORT static Expr make(const std::string &name, const Expr &value, const Expr &body); make 262 src/IR.h EXPORT static Stmt make(const std::string &name, const Expr &value, const Stmt &body); make 274 src/IR.h EXPORT static Stmt make(const Expr &condition, const Expr &message); make 295 src/IR.h EXPORT static Stmt make(const std::string &name, bool is_producer, const Stmt &body); make 314 src/IR.h EXPORT static Stmt make(const std::string &name, const Expr &value, const Expr &index, make 330 src/IR.h EXPORT static Stmt make(const std::string &name, const std::vector<Expr> &values, const std::vector<Expr> &args); make 359 src/IR.h EXPORT static Stmt make(const std::string &name, Type type, const std::vector<Expr> &extents, make 378 src/IR.h EXPORT static Stmt make(const std::string &name); make 409 src/IR.h EXPORT static Stmt make(const std::string &name, const std::vector<Type> &types, const Region &bounds, const Expr &condition, const Stmt &body); make 420 src/IR.h EXPORT static Stmt make(const Stmt &first, const Stmt &rest); make 423 src/IR.h EXPORT static Stmt make(const std::vector<Stmt> &stmts); make 433 src/IR.h EXPORT static Stmt make(const Expr &condition, const Stmt &then_case, const Stmt &else_case = Stmt()); make 442 src/IR.h EXPORT static Stmt make(const Expr &v); make 559 src/IR.h EXPORT static Expr make(Type type, const std::string &name, const std::vector<Expr> &args, CallType call_type, make 564 src/IR.h EXPORT static Expr make(Function func, const std::vector<Expr> &args, int idx = 0); make 567 src/IR.h static Expr make(Buffer<> image, const std::vector<Expr> &args) { make 568 src/IR.h return make(image.type(), image.name(), args, Image, nullptr, 0, image, Parameter()); make 572 src/IR.h static Expr make(Parameter param, const std::vector<Expr> &args) { make 573 src/IR.h return make(param.type(), param.name(), args, Image, nullptr, 0, Buffer<>(), param); make 614 src/IR.h static Expr make(Type type, const std::string &name) { make 615 src/IR.h return make(type, name, Buffer<>(), Parameter(), ReductionDomain()); make 618 src/IR.h static Expr make(Type type, const std::string &name, Parameter param) { make 619 src/IR.h return make(type, name, Buffer<>(), param, ReductionDomain()); make 622 src/IR.h static Expr make(Type type, const std::string &name, Buffer<> image) { make 623 src/IR.h return make(type, name, image, Parameter(), ReductionDomain()); make 626 src/IR.h static Expr make(Type type, const std::string &name, ReductionDomain reduction_domain) { make 627 src/IR.h return make(type, name, Buffer<>(), Parameter(), reduction_domain); make 630 src/IR.h EXPORT static Expr make(Type type, const std::string &name, Buffer<> image, make 655 src/IR.h EXPORT static Stmt make(const std::string &name, const Expr &min, const Expr &extent, ForType for_type, DeviceAPI device_api, const Stmt &body); make 676 src/IR.h EXPORT static Expr make(const std::vector<Expr> &vectors, make 729 src/IR.h EXPORT static Stmt make(const std::string &name, const std::vector<Type> &types, make 544 src/IREquality.cpp Expr x = Variable::make(Int(32), "x"); make 545 src/IREquality.cpp check_equal(Ramp::make(x, 4, 3), Ramp::make(x, 4, 3)); make 546 src/IREquality.cpp check_not_equal(Ramp::make(x, 2, 3), Ramp::make(x, 4, 3)); make 548 src/IREquality.cpp check_equal(x, Variable::make(Int(32), "x")); make 549 src/IREquality.cpp check_not_equal(x, Variable::make(Int(32), "y")); make 18 src/IRMatch.cpp Expr w = Variable::make(Int(32), "*"); make 19 src/IRMatch.cpp Expr fw = Variable::make(Float(32), "*"); make 20 src/IRMatch.cpp Expr x = Variable::make(Int(32), "x"); make 21 src/IRMatch.cpp Expr y = Variable::make(Int(32), "y"); make 22 src/IRMatch.cpp Expr fx = Variable::make(Float(32), "fx"); make 23 src/IRMatch.cpp Expr fy = Variable::make(Float(32), "fy"); make 25 src/IRMatch.cpp Expr vec_wild = Variable::make(Int(32, 4), "*"); make 47 src/IRMatch.cpp internal_assert(expr_match(vec_wild * 3, Ramp::make(x, y, 4) * 3, matches)); make 38 src/IRMutator.cpp *expr = T::make(a, b); make 76 src/IRMutator.cpp expr = Cast::make(op->type, value); make 99 src/IRMutator.cpp else expr = Not::make(a); make 111 src/IRMutator.cpp expr = Select::make(cond, t, f); make 121 src/IRMutator.cpp expr = Load::make(op->type, op->name, index, op->image, op->param, predicate); make 132 src/IRMutator.cpp expr = Ramp::make(base, stride, op->lanes); make 139 src/IRMutator.cpp else expr = Broadcast::make(value, op->lanes); make 157 src/IRMutator.cpp expr = Call::make(op->type, op->name, new_args, op->call_type, make 169 src/IRMutator.cpp expr = Let::make(op->name, value, body); make 180 src/IRMutator.cpp stmt = LetStmt::make(op->name, value, body); make 191 src/IRMutator.cpp stmt = AssertStmt::make(condition, message); make 200 src/IRMutator.cpp stmt = ProducerConsumer::make(op->name, op->is_producer, body); make 213 src/IRMutator.cpp stmt = For::make(op->name, min, extent, op->for_type, op->device_api, body); make 224 src/IRMutator.cpp stmt = Store::make(op->name, value, index, op->param, predicate); make 251 src/IRMutator.cpp stmt = Provide::make(op->name, new_values, new_args); make 274 src/IRMutator.cpp stmt = Allocate::make(op->name, op->type, new_extents, condition, body, new_expr, op->free_function); make 296 src/IRMutator.cpp stmt = Realize::make(op->name, op->types, new_bounds, make 311 src/IRMutator.cpp stmt = Prefetch::make(op->name, op->types, new_bounds, op->param); make 322 src/IRMutator.cpp stmt = Block::make(first, rest); make 335 src/IRMutator.cpp stmt = IfThenElse::make(condition, then_case, else_case); make 344 src/IRMutator.cpp stmt = Evaluate::make(v); make 362 src/IRMutator.cpp expr = Shuffle::make(new_vectors, op->indices); make 257 src/IROperator.cpp return Broadcast::make(make_const(t.element_of(), val), t.lanes()); make 259 src/IROperator.cpp return IntImm::make(t, (int64_t)val); make 261 src/IROperator.cpp return UIntImm::make(t, (uint64_t)val); make 263 src/IROperator.cpp return FloatImm::make(t, (double)val); make 331 src/IROperator.cpp return Broadcast::make(v, b->lanes); make 388 src/IROperator.cpp a = Broadcast::make(a, b.type().lanes()); make 390 src/IROperator.cpp b = Broadcast::make(b, a.type().lanes()); make 461 src/IROperator.cpp Expr nan = Call::make(type, "nan_f32", {}, Call::PureExtern); make 462 src/IROperator.cpp Expr neg_inf = Call::make(type, "neg_inf_f32", {}, Call::PureExtern); make 531 src/IROperator.cpp Expr inf = Call::make(type, "inf_f32", {}, Call::PureExtern); make 623 src/IROperator.cpp Expr sz = Call::make(Int(32), Call::size_of_halide_buffer_t, {}, Call::Intrinsic); make 624 src/IROperator.cpp args[0] = Call::make(type_of<struct halide_buffer_t *>(), Call::alloca, {sz}, Call::Intrinsic); make 628 src/IROperator.cpp Expr shape_var = Variable::make(type_of<halide_dimension_t *>(), shape_var_name); make 683 src/IROperator.cpp Expr shape_arg = Call::make(type_of<halide_dimension_t *>(), Call::make_struct, shape, Call::Intrinsic); make 705 src/IROperator.cpp Expr e = Call::make(type_of<struct halide_buffer_t *>(), Call::buffer_init, args, Call::Extern); make 708 src/IROperator.cpp e = Let::make(shape_var_name, shape_arg, e); make 769 src/IROperator.cpp return Internal::Call::make(type_of<const char *>(), Internal::Call::stringify, make 793 src/IROperator.cpp Internal::Call::make(Int(32), "halide_print", make 798 src/IROperator.cpp Internal::Call::make(args[0].type(), Internal::Call::return_second, make 805 src/IROperator.cpp return Internal::Call::make(p.type(), make 817 src/IROperator.cpp Internal::Call::make(Int(32), make 825 src/IROperator.cpp return Internal::Call::make(args[0].type(), make 837 src/IROperator.cpp return Internal::Call::make(result.type(), Internal::Call::memoize_expr, make 227 src/IROperator.h return Internal::Broadcast::make(cast(t.element_of(), a), t.lanes()); make 230 src/IROperator.h return Internal::Broadcast::make(cast(t.element_of(), b->value), t.lanes()); make 233 src/IROperator.h return Internal::Cast::make(t, a); make 241 src/IROperator.h return Internal::Add::make(a, b); make 251 src/IROperator.h return Internal::Add::make(a, Internal::make_const(a.type(), b)); make 260 src/IROperator.h return Internal::Add::make(Internal::make_const(b.type(), a), b); make 268 src/IROperator.h a = Internal::Add::make(a, cast(a.type(), b)); make 277 src/IROperator.h return Internal::Sub::make(a, b); make 286 src/IROperator.h return Internal::Sub::make(a, Internal::make_const(a.type(), b)); make 295 src/IROperator.h return Internal::Sub::make(Internal::make_const(b.type(), a), b); make 305 src/IROperator.h return Internal::Sub::make(Internal::make_zero(a.type()), a); make 313 src/IROperator.h a = Internal::Sub::make(a, cast(a.type(), b)); make 322 src/IROperator.h return Internal::Mul::make(a, b); make 331 src/IROperator.h return Internal::Mul::make(a, Internal::make_const(a.type(), b)); make 340 src/IROperator.h return Internal::Mul::make(Internal::make_const(b.type(), a), b); make 348 src/IROperator.h a = Internal::Mul::make(a, cast(a.type(), b)); make 359 src/IROperator.h return Internal::Div::make(a, b); make 369 src/IROperator.h a = Internal::Div::make(a, cast(a.type(), b)); make 381 src/IROperator.h return Internal::Div::make(a, Internal::make_const(a.type(), b)); make 390 src/IROperator.h return Internal::Div::make(Internal::make_const(b.type(), a), b); make 403 src/IROperator.h return Internal::Mod::make(a, b); make 413 src/IROperator.h return Internal::Mod::make(a, Internal::make_const(a.type(), b)); make 422 src/IROperator.h return Internal::Mod::make(Internal::make_const(b.type(), a), b); make 431 src/IROperator.h return Internal::GT::make(a, b); make 441 src/IROperator.h return Internal::GT::make(a, Internal::make_const(a.type(), b)); make 451 src/IROperator.h return Internal::GT::make(Internal::make_const(b.type(), a), b); make 460 src/IROperator.h return Internal::LT::make(a, b); make 470 src/IROperator.h return Internal::LT::make(a, Internal::make_const(a.type(), b)); make 480 src/IROperator.h return Internal::LT::make(Internal::make_const(b.type(), a), b); make 489 src/IROperator.h return Internal::LE::make(a, b); make 499 src/IROperator.h return Internal::LE::make(a, Internal::make_const(a.type(), b)); make 509 src/IROperator.h return Internal::LE::make(Internal::make_const(b.type(), a), b); make 518 src/IROperator.h return Internal::GE::make(a, b); make 528 src/IROperator.h return Internal::GE::make(a, Internal::make_const(a.type(), b)); make 538 src/IROperator.h return Internal::GE::make(Internal::make_const(b.type(), a), b); make 547 src/IROperator.h return Internal::EQ::make(a, b); make 557 src/IROperator.h return Internal::EQ::make(a, Internal::make_const(a.type(), b)); make 567 src/IROperator.h return Internal::EQ::make(Internal::make_const(b.type(), a), b); make 576 src/IROperator.h return Internal::NE::make(a, b); make 586 src/IROperator.h return Internal::NE::make(a, Internal::make_const(a.type(), b)); make 596 src/IROperator.h return Internal::NE::make(Internal::make_const(b.type(), a), b); make 602 src/IROperator.h return Internal::And::make(a, b); make 625 src/IROperator.h return Internal::Or::make(a, b); make 648 src/IROperator.h return Internal::Not::make(a); make 659 src/IROperator.h return Internal::Max::make(a, b); make 670 src/IROperator.h return Internal::Max::make(a, Internal::make_const(a.type(), b)); make 682 src/IROperator.h return Internal::Max::make(Internal::make_const(b.type(), a), b); make 704 src/IROperator.h return Internal::Min::make(a, b); make 715 src/IROperator.h return Internal::Min::make(a, Internal::make_const(a.type(), b)); make 726 src/IROperator.h return Internal::Min::make(Internal::make_const(b.type(), a), b); make 783 src/IROperator.h return Internal::Max::make(Internal::Min::make(a, n_max_val), n_min_val); make 798 src/IROperator.h return Internal::Call::make(t.with_code(t.is_int() ? Type::UInt : t.code()), make 818 src/IROperator.h return Internal::Call::make(t.with_code(t.is_int() ? Type::UInt : t.code()), make 851 src/IROperator.h return Internal::Select::make(condition, true_value, false_value); make 873 src/IROperator.h return Internal::Call::make(Float(64), "sin_f64", {x}, Internal::Call::PureExtern); make 876 src/IROperator.h return Internal::Call::make(Float(16), "sin_f16", {x}, Internal::Call::PureExtern); make 879 src/IROperator.h return Internal::Call::make(Float(32), "sin_f32", {cast<float>(x)}, Internal::Call::PureExtern); make 889 src/IROperator.h return Internal::Call::make(Float(64), "asin_f64", {x}, Internal::Call::PureExtern); make 892 src/IROperator.h return Internal::Call::make(Float(16), "asin_f16", {x}, Internal::Call::PureExtern); make 895 src/IROperator.h return Internal::Call::make(Float(32), "asin_f32", {cast<float>(x)}, Internal::Call::PureExtern); make 905 src/IROperator.h return Internal::Call::make(Float(64), "cos_f64", {x}, Internal::Call::PureExtern); make 908 src/IROperator.h return Internal::Call::make(Float(16), "cos_f16", {x}, Internal::Call::PureExtern); make 911 src/IROperator.h return Internal::Call::make(Float(32), "cos_f32", {cast<float>(x)}, Internal::Call::PureExtern); make 921 src/IROperator.h return Internal::Call::make(Float(64), "acos_f64", {x}, Internal::Call::PureExtern); make 924 src/IROperator.h return Internal::Call::make(Float(16), "acos_f16", {x}, Internal::Call::PureExtern); make 927 src/IROperator.h return Internal::Call::make(Float(32), "acos_f32", {cast<float>(x)}, Internal::Call::PureExtern); make 937 src/IROperator.h return Internal::Call::make(Float(64), "tan_f64", {x}, Internal::Call::PureExtern); make 940 src/IROperator.h return Internal::Call::make(Float(16), "tan_f16", {x}, Internal::Call::PureExtern); make 943 src/IROperator.h return Internal::Call::make(Float(32), "tan_f32", {cast<float>(x)}, Internal::Call::PureExtern); make 953 src/IROperator.h return Internal::Call::make(Float(64), "atan_f64", {x}, Internal::Call::PureExtern); make 956 src/IROperator.h return Internal::Call::make(Float(16), "atan_f16", {x}, Internal::Call::PureExtern); make 959 src/IROperator.h return Internal::Call::make(Float(32), "atan_f32", {cast<float>(x)}, Internal::Call::PureExtern); make 971 src/IROperator.h return Internal::Call::make(Float(64), "atan2_f64", {y, x}, Internal::Call::PureExtern); make 975 src/IROperator.h return Internal::Call::make(Float(16), "atan2_f16", {y, x}, Internal::Call::PureExtern); make 980 src/IROperator.h return Internal::Call::make(Float(32), "atan2_f32", {y, x}, Internal::Call::PureExtern); make 990 src/IROperator.h return Internal::Call::make(Float(64), "sinh_f64", {x}, Internal::Call::PureExtern); make 993 src/IROperator.h return Internal::Call::make(Float(16), "sinh_f16", {x}, Internal::Call::PureExtern); make 996 src/IROperator.h return Internal::Call::make(Float(32), "sinh_f32", {cast<float>(x)}, Internal::Call::PureExtern); make 1006 src/IROperator.h return Internal::Call::make(Float(64), "asinh_f64", {x}, Internal::Call::PureExtern); make 1009 src/IROperator.h return Internal::Call::make(Float(16), "asinh_f16", {x}, Internal::Call::PureExtern); make 1012 src/IROperator.h return Internal::Call::make(Float(32), "asinh_f32", {cast<float>(x)}, Internal::Call::PureExtern); make 1022 src/IROperator.h return Internal::Call::make(Float(64), "cosh_f64", {x}, Internal::Call::PureExtern); make 1025 src/IROperator.h return Internal::Call::make(Float(16), "cosh_f16", {x}, Internal::Call::PureExtern); make 1028 src/IROperator.h return Internal::Call::make(Float(32), "cosh_f32", {cast<float>(x)}, Internal::Call::PureExtern); make 1038 src/IROperator.h return Internal::Call::make(Float(64), "acosh_f64", {x}, Internal::Call::PureExtern); make 1041 src/IROperator.h return Internal::Call::make(Float(16), "acosh_f16", {x}, Internal::Call::PureExtern); make 1044 src/IROperator.h return Internal::Call::make(Float(32), "acosh_f32", {cast<float>(x)}, Internal::Call::PureExtern); make 1054 src/IROperator.h return Internal::Call::make(Float(64), "tanh_f64", {x}, Internal::Call::PureExtern); make 1057 src/IROperator.h return Internal::Call::make(Float(16), "tanh_f16", {x}, Internal::Call::PureExtern); make 1060 src/IROperator.h return Internal::Call::make(Float(32), "tanh_f32", {cast<float>(x)}, Internal::Call::PureExtern); make 1070 src/IROperator.h return Internal::Call::make(Float(64), "atanh_f64", {x}, Internal::Call::PureExtern); make 1073 src/IROperator.h return Internal::Call::make(Float(16), "atanh_f16", {x}, Internal::Call::PureExtern); make 1076 src/IROperator.h return Internal::Call::make(Float(32), "atanh_f32", {cast<float>(x)}, Internal::Call::PureExtern); make 1086 src/IROperator.h return Internal::Call::make(Float(64), "sqrt_f64", {x}, Internal::Call::PureExtern); make 1089 src/IROperator.h return Internal::Call::make(Float(16), "sqrt_f16", {x}, Internal::Call::PureExtern); make 1092 src/IROperator.h return Internal::Call::make(Float(32), "sqrt_f32", {cast<float>(x)}, Internal::Call::PureExtern); make 1113 src/IROperator.h return Internal::Call::make(Float(64), "exp_f64", {x}, Internal::Call::PureExtern); make 1116 src/IROperator.h return Internal::Call::make(Float(16), "exp_f16", {x}, Internal::Call::PureExtern); make 1119 src/IROperator.h return Internal::Call::make(Float(32), "exp_f32", {cast<float>(x)}, Internal::Call::PureExtern); make 1133 src/IROperator.h return Internal::Call::make(Float(64), "log_f64", {x}, Internal::Call::PureExtern); make 1136 src/IROperator.h return Internal::Call::make(Float(16), "log_f16", {x}, Internal::Call::PureExtern); make 1139 src/IROperator.h return Internal::Call::make(Float(32), "log_f32", {cast<float>(x)}, Internal::Call::PureExtern); make 1158 src/IROperator.h return Internal::Call::make(Float(64), "pow_f64", {x, y}, Internal::Call::PureExtern); make 1162 src/IROperator.h return Internal::Call::make(Float(16), "pow_f16", {x, y}, Internal::Call::PureExtern); make 1167 src/IROperator.h return Internal::Call::make(Float(32), "pow_f32", {x, y}, Internal::Call::PureExtern); make 1210 src/IROperator.h return Internal::Call::make(x.type(), "fast_inverse_f32", {x}, Internal::Call::PureExtern); make 1218 src/IROperator.h return Internal::Call::make(x.type(), "fast_inverse_sqrt_f32", {x}, Internal::Call::PureExtern); make 1228 src/IROperator.h return Internal::Call::make(x.type(), "floor_f64", {x}, Internal::Call::PureExtern); make 1231 src/IROperator.h return Internal::Call::make(Float(16), "floor_f16", {x}, Internal::Call::PureExtern); make 1235 src/IROperator.h return Internal::Call::make(t, "floor_f32", {cast(t, x)}, Internal::Call::PureExtern); make 1246 src/IROperator.h return Internal::Call::make(x.type(), "ceil_f64", {x}, Internal::Call::PureExtern); make 1249 src/IROperator.h return Internal::Call::make(Float(16), "ceil_f16", {x}, Internal::Call::PureExtern); make 1253 src/IROperator.h return Internal::Call::make(t, "ceil_f32", {cast(t, x)}, Internal::Call::PureExtern); make 1265 src/IROperator.h return Internal::Call::make(Float(64), "round_f64", {x}, Internal::Call::PureExtern); make 1268 src/IROperator.h return Internal::Call::make(Float(16), "round_f16", {x}, Internal::Call::PureExtern); make 1272 src/IROperator.h return Internal::Call::make(t, "round_f32", {cast(t, x)}, Internal::Call::PureExtern); make 1282 src/IROperator.h return Internal::Call::make(Float(64), "trunc_f64", {x}, Internal::Call::PureExtern); make 1285 src/IROperator.h return Internal::Call::make(Float(16), "trunc_f16", {x}, Internal::Call::PureExtern); make 1289 src/IROperator.h return Internal::Call::make(t, "trunc_f32", {cast(t, x)}, Internal::Call::PureExtern); make 1300 src/IROperator.h return Internal::Call::make(t, "is_nan_f64", {x}, Internal::Call::PureExtern); make 1303 src/IROperator.h return Internal::Call::make(t, "is_nan_f16", {x}, Internal::Call::PureExtern); make 1307 src/IROperator.h return Internal::Call::make(t, "is_nan_f32", {cast(ft, x)}, Internal::Call::PureExtern); make 1329 src/IROperator.h return Internal::Call::make(t, Internal::Call::reinterpret, {e}, Internal::Call::PureIntrinsic); make 1353 src/IROperator.h return Internal::Call::make(x.type(), Internal::Call::bitwise_and, {x, y}, Internal::Call::PureIntrinsic); make 1372 src/IROperator.h return Internal::Call::make(x.type(), Internal::Call::bitwise_or, {x, y}, Internal::Call::PureIntrinsic); make 1391 src/IROperator.h return Internal::Call::make(x.type(), Internal::Call::bitwise_xor, {x, y}, Internal::Call::PureIntrinsic); make 1399 src/IROperator.h return Internal::Call::make(x.type(), Internal::Call::bitwise_not, {x}, Internal::Call::PureIntrinsic); make 1415 src/IROperator.h return Internal::Call::make(x.type(), Internal::Call::shift_left, {x, y}, Internal::Call::PureIntrinsic); make 1441 src/IROperator.h return Internal::Call::make(x.type(), Internal::Call::shift_right, {x, y}, Internal::Call::PureIntrinsic); make 1555 src/IROperator.h return Internal::Call::make(zero_val.type(), Internal::Call::lerp, make 1563 src/IROperator.h return Internal::Call::make(x.type(), Internal::Call::popcount, make 1571 src/IROperator.h return Internal::Call::make(x.type(), Internal::Call::count_leading_zeros, make 1579 src/IROperator.h return Internal::Call::make(x.type(), Internal::Call::count_trailing_zeros, make 1596 src/IROperator.h return Internal::Call::make(x.type(), Internal::Call::div_round_to_zero, make 1615 src/IROperator.h return Internal::Call::make(x.type(), Internal::Call::mod_round_to_zero, make 1665 src/IROperator.h return Internal::Call::make(Float(32), Internal::Call::random, make 1685 src/IROperator.h return Internal::Call::make(UInt(32), Internal::Call::random, make 1794 src/IROperator.h return Internal::Call::make(t, Internal::Call::undef, make 1856 src/IROperator.h return Internal::Call::make(e.type(), Internal::Call::likely, make 1863 src/IROperator.h return Internal::Call::make(e.type(), Internal::Call::likely_if_innermost, make 103 src/IRPrinter.cpp Expr x = Variable::make(Int(32), "x"); make 104 src/IRPrinter.cpp Expr y = Variable::make(Int(32), "y"); make 109 src/IRPrinter.cpp Stmt store = Store::make("buf", (x * 17) / (x - 3), y - 1, Parameter(), const_true()); make 110 src/IRPrinter.cpp Stmt for_loop = For::make("x", -2, y + 2, ForType::Parallel, DeviceAPI::Host, store); make 112 src/IRPrinter.cpp Expr call = Call::make(i32, "buf", args, Call::Extern); make 113 src/IRPrinter.cpp Stmt store2 = Store::make("out", call + 1, x, Parameter(), const_true()); make 114 src/IRPrinter.cpp Stmt for_loop2 = For::make("x", 0, y, ForType::Vectorized , DeviceAPI::Host, store2); make 118 src/IRPrinter.cpp Stmt pipeline = Block::make(producer, consumer); make 120 src/IRPrinter.cpp Stmt assertion = AssertStmt::make(y >= 3, Call::make(Int(32), "halide_error_param_too_small_i64", make 122 src/IRPrinter.cpp Stmt block = Block::make(assertion, pipeline); make 123 src/IRPrinter.cpp Stmt let_stmt = LetStmt::make("y", 17, block); make 124 src/IRPrinter.cpp Stmt allocate = Allocate::make("buf", f32, {1023}, const_true(), let_stmt); make 28 src/ImageParam.cpp func(args) = Internal::Call::make(param, args_expr); make 19 src/InjectHostDevBufferCopies.cpp Expr call = Call::make(Int(32), name, args, Call::Extern); make 21 src/InjectHostDevBufferCopies.cpp Expr call_result_var = Variable::make(Int(32), call_result_name); make 22 src/InjectHostDevBufferCopies.cpp return LetStmt::make(call_result_name, call, make 23 src/InjectHostDevBufferCopies.cpp AssertStmt::make(EQ::make(call_result_var, 0), call_result_var)); make 216 src/InjectHostDevBufferCopies.cpp return Call::make(type_of<const char *>(), interface_name, no_args, Call::Extern); make 220 src/InjectHostDevBufferCopies.cpp Expr buf = Variable::make(type_of<struct halide_buffer_t *>(), buf_name + ".buffer"); make 226 src/InjectHostDevBufferCopies.cpp Evaluate::make(Call::make(Int(32), Call::register_destructor, make 229 src/InjectHostDevBufferCopies.cpp return Block::make(device_malloc, destructor); make 241 src/InjectHostDevBufferCopies.cpp Expr buffer = Variable::make(type_of<struct halide_buffer_t *>(), buf_name + ".buffer"); make 361 src/InjectHostDevBufferCopies.cpp Expr buffer = Variable::make(type_of<struct halide_buffer_t *>(), i.first + ".buffer"); make 366 src/InjectHostDevBufferCopies.cpp Expr set_host_dirty = Call::make(Int(32), Call::buffer_set_host_dirty, make 368 src/InjectHostDevBufferCopies.cpp s = Block::make(s, Evaluate::make(set_host_dirty)); make 373 src/InjectHostDevBufferCopies.cpp Expr set_device_dirty = Call::make(Int(32), Call::buffer_set_device_dirty, make 375 src/InjectHostDevBufferCopies.cpp s = Block::make(s, Evaluate::make(set_device_dirty)); make 384 src/InjectHostDevBufferCopies.cpp s = Block::make(make_buffer_copy(direction, i.first, touching_device), s); make 395 src/InjectHostDevBufferCopies.cpp s = Block::make(dev_malloc, s); make 472 src/InjectHostDevBufferCopies.cpp stmt = ProducerConsumer::make(op->name, op->is_producer, body); make 498 src/InjectHostDevBufferCopies.cpp stmt = Block::make(make_buffer_copy(ToDevice, buf_name, i.second.current_device), stmt); make 557 src/InjectHostDevBufferCopies.cpp stmt = Allocate::make(op->name, op->type, op->extents, const_false(), op->body); make 586 src/InjectHostDevBufferCopies.cpp inner_body = Allocate::make(op->name, op->type, op->extents, op->condition, inner_body, make 587 src/InjectHostDevBufferCopies.cpp Call::make(Handle(), Call::buffer_get_host, make 588 src/InjectHostDevBufferCopies.cpp { Variable::make(type_of<struct halide_buffer_t *>(), op->name + ".buffer") }, make 592 src/InjectHostDevBufferCopies.cpp inner_body = Block::make(combined_malloc, inner_body); make 605 src/InjectHostDevBufferCopies.cpp stmt = LetStmt::make(op->name + ".buffer", buf, inner_body); make 609 src/InjectHostDevBufferCopies.cpp stmt = LetStmt::make(body_lets[i - 1]->name, body_lets[i - 1]->value, stmt); make 634 src/InjectHostDevBufferCopies.cpp stmt = LetStmt::make(op->name, value, op->body); make 706 src/InjectHostDevBufferCopies.cpp stmt = IfThenElse::make(cond, then_case, else_case); make 725 src/InjectHostDevBufferCopies.cpp stmt = Block::make(first, rest); make 43 src/InjectImageIntrinsics.cpp Variable::make(type_of<struct halide_buffer_t *>(), provide->name + ".buffer"), make 49 src/InjectImageIntrinsics.cpp stmt = Evaluate::make(Call::make(value_arg.type(), make 84 src/InjectImageIntrinsics.cpp args[1] = Variable::make(type_of<struct halide_buffer_t *>(), call->name + ".buffer"); make 105 src/InjectImageIntrinsics.cpp Expr min = Variable::make(Int(32), min_name); make 107 src/InjectImageIntrinsics.cpp args.push_back(Variable::make(Int(32), extent_name)); make 118 src/InjectImageIntrinsics.cpp Call::make(load_type, make 53 src/InjectOpenGLIntrinsics.cpp (Cast::make(Float(32), mutate(call_args[from_index])) + 0.5f) / make 72 src/InjectOpenGLIntrinsics.cpp expr = Call::make(call->type, Call::glsl_texture_load, make 86 src/InjectOpenGLIntrinsics.cpp expr = Call::make(call->type, Call::glsl_texture_store, make 115 src/Inline.cpp body = Let::make(func.name() + "." + func_args[i], args[i], body); make 44 src/InlineReductions.cpp expr = Let::make(op->name, value, body); make 68 src/InlineReductions.cpp expr = Variable::make(v->type, var_name); make 49 src/Interval.cpp return Max::make(a, b); make 90 src/Interval.cpp return Min::make(a, b); make 116 src/Interval.cpp Expr Interval::pos_inf = Variable::make(Handle(), "pos_inf"); make 117 src/Interval.cpp Expr Interval::neg_inf = Variable::make(Handle(), "neg_inf"); make 133 src/Interval.cpp Expr x = Variable::make(Int(32), "x"); make 35 src/Lerp.cpp zero_val = Cast::make(computation_type, zero_val) - bias_value; make 36 src/Lerp.cpp one_val = Cast::make(computation_type, one_val) - bias_value; make 60 src/Lerp.cpp Cast::make(computation_type, make 62 src/Lerp.cpp Cast::make(Float(64, typed_weight.type().lanes()), typed_weight)); make 65 src/Lerp.cpp Cast::make(computation_type, make 80 src/Lerp.cpp Cast::make(computation_type, make 84 src/Lerp.cpp Cast::make(computation_type, make 104 src/Lerp.cpp typed_weight = Cast::make(computation_type, weight); make 117 src/Lerp.cpp Cast::make(computation_type, weight) * make 121 src/Lerp.cpp Cast::make(computation_type, make 126 src/Lerp.cpp Cast::make(computation_type, make 143 src/Lerp.cpp Expr zero_expand = Cast::make(UInt(2 * bits, computation_type.lanes()), make 145 src/Lerp.cpp Expr one_expand = Cast::make(UInt(2 * bits, one_val.type().lanes()), make 148 src/Lerp.cpp Expr rounding = Cast::make(UInt(2 * bits), 1) << Cast::make(UInt(2 * bits), (bits - 1)); make 149 src/Lerp.cpp Expr divisor = Cast::make(UInt(2 * bits), 1) << Cast::make(UInt(2 * bits), bits); make 155 src/Lerp.cpp result = Cast::make(UInt(bits, computation_type.lanes()), divided); make 170 src/Lerp.cpp result = Cast::make(result_type, result + bias_value); make 130 src/LoopCarry.cpp return Ramp::make(i * t.lanes(), 1, t.lanes()); make 212 src/LoopCarry.cpp stmt = LetStmt::make(op->name, value, body); make 233 src/LoopCarry.cpp result.push_back(lift_carried_values_out_of_stmt(Block::make(stores))); make 240 src/LoopCarry.cpp result.push_back(lift_carried_values_out_of_stmt(Block::make(stores))); make 243 src/LoopCarry.cpp stmt = Block::make(result); make 392 src/LoopCarry.cpp Expr load_from_scratch = Load::make(orig_load->type, scratch, scratch_idx, make 399 src/LoopCarry.cpp Stmt store_to_scratch = Store::make(scratch, orig_load, scratch_idx, make 406 src/LoopCarry.cpp Stmt shuffle = Store::make(scratch, load_from_scratch, make 420 src/LoopCarry.cpp Expr call = Call::make(Int(32), unique_name('b'), initial_scratch_values, Call::PureIntrinsic); make 435 src/LoopCarry.cpp Stmt store_to_scratch = Store::make(scratch, initial_scratch_values[i], make 441 src/LoopCarry.cpp Stmt initial_stores = Block::make(initial_scratch_stores); make 446 src/LoopCarry.cpp initial_stores = LetStmt::make(l.first, l.second, initial_stores); make 453 src/LoopCarry.cpp initial_stores = LetStmt::make(l.first, l.second, initial_stores); make 463 src/LoopCarry.cpp Stmt s = Block::make(not_first_iteration_scratch_stores); make 464 src/LoopCarry.cpp s = Block::make(s, core); make 465 src/LoopCarry.cpp s = Block::make(s, Block::make(scratch_shuffles)); make 511 src/LoopCarry.cpp stmt = ProducerConsumer::make(op->name, op->is_producer, body); make 523 src/LoopCarry.cpp stmt = For::make(op->name, op->min, op->extent, op->for_type, op->device_api, body); make 528 src/LoopCarry.cpp stmt = Block::make(substitute(op->name, op->min, alloc.initial_stores), stmt); make 529 src/LoopCarry.cpp stmt = Allocate::make(alloc.name, alloc.type, {alloc.size}, const_true(), stmt); make 532 src/LoopCarry.cpp stmt = IfThenElse::make(op->extent > 0, stmt); make 101 src/Memoization.cpp info.value_expr = Internal::Variable::make(info.type, parameter.name(), parameter); make 220 src/Memoization.cpp writes.push_back(Store::make(key_name, make 221 src/Memoization.cpp StringImm::make(std::to_string(top_level_name.size()) + ":" + top_level_name + make 229 src/Memoization.cpp writes.push_back(Store::make(key_name, make 239 src/Memoization.cpp writes.push_back(Store::make(key_name, Cast::make(UInt(8), 0), make 247 src/Memoization.cpp writes.push_back(Store::make(key_name, make 253 src/Memoization.cpp Stmt blocks = Block::make(writes); make 265 src/Memoization.cpp args.push_back(Variable::make(type_of<uint8_t *>(), key_allocation_name)); make 267 src/Memoization.cpp args.push_back(Variable::make(type_of<halide_buffer_t *>(), computed_bounds_name)); make 271 src/Memoization.cpp buffers.push_back(Variable::make(type_of<halide_buffer_t *>(), storage_base_name + ".buffer")); make 274 src/Memoization.cpp buffers.push_back(Variable::make(type_of<halide_buffer_t *>(), storage_base_name + "." + std::to_string(i) + ".buffer")); make 277 src/Memoization.cpp args.push_back(Call::make(type_of<halide_buffer_t **>(), Call::make_struct, buffers, Call::Intrinsic)); make 279 src/Memoization.cpp return Call::make(Int(32), "halide_memoization_cache_lookup", args, Call::Extern); make 286 src/Memoization.cpp args.push_back(Variable::make(type_of<uint8_t *>(), key_allocation_name)); make 288 src/Memoization.cpp args.push_back(Variable::make(type_of<halide_buffer_t *>(), computed_bounds_name)); make 292 src/Memoization.cpp buffers.push_back(Variable::make(type_of<halide_buffer_t *>(), storage_base_name + ".buffer")); make 295 src/Memoization.cpp buffers.push_back(Variable::make(type_of<halide_buffer_t *>(), storage_base_name + "." + std::to_string(i) + ".buffer")); make 298 src/Memoization.cpp args.push_back(Call::make(type_of<halide_buffer_t **>(), Call::make_struct, buffers, Call::Intrinsic)); make 301 src/Memoization.cpp return Evaluate::make(Call::make(Int(32), "halide_memoization_cache_store", args, Call::Extern)); make 355 src/Memoization.cpp Stmt cache_miss_marker = LetStmt::make(cache_miss_name, make 356 src/Memoization.cpp Cast::make(Bool(), Variable::make(Int(32), cache_result_name)), make 358 src/Memoization.cpp Stmt cache_lookup_check = Block::make(AssertStmt::make(NE::make(Variable::make(Int(32), cache_result_name), -1), make 359 src/Memoization.cpp Call::make(Int(32), "halide_error_out_of_memory", { }, Call::Extern)), make 362 src/Memoization.cpp Stmt cache_lookup = LetStmt::make(cache_result_name, make 372 src/Memoization.cpp Expr min = Variable::make(Int(32), prefix + ".min"); make 373 src/Memoization.cpp Expr max = Variable::make(Int(32), prefix + ".max"); make 379 src/Memoization.cpp Stmt computed_bounds_let = LetStmt::make(computed_bounds_name, computed_bounds, cache_lookup); make 381 src/Memoization.cpp Stmt generate_key = Block::make(key_info.generate_key(cache_key_name), computed_bounds_let); make 383 src/Memoization.cpp Allocate::make(cache_key_name, UInt(8), {key_info.key_size()}, make 386 src/Memoization.cpp stmt = Realize::make(op->name, op->types, op->bounds, op->condition, cache_key_alloc); make 403 src/Memoization.cpp Expr cache_miss = Variable::make(Bool(), cache_miss_name); make 406 src/Memoization.cpp Stmt mutated_body = IfThenElse::make(cache_miss, body); make 407 src/Memoization.cpp stmt = ProducerConsumer::make(op->name, op->is_producer, mutated_body); make 416 src/Memoization.cpp IfThenElse::make(cache_miss, key_info.store_computation(cache_key_name, computed_bounds_name, f.outputs(), op->name)); make 418 src/Memoization.cpp Stmt mutated_body = Block::make(cache_store_back, body); make 419 src/Memoization.cpp stmt = ProducerConsumer::make(op->name, op->is_producer, mutated_body); make 491 src/Memoization.cpp expr = Call::make(type_of<struct halide_buffer_t *>(), Call::buffer_init, make 512 src/Memoization.cpp body = Allocate::make(allocation->name, allocation->type, allocation->extents, allocation->condition, body, make 513 src/Memoization.cpp Call::make(Handle(), Call::buffer_get_host, make 514 src/Memoization.cpp { Variable::make(type_of<struct halide_buffer_t *>(), allocation->name + ".buffer") }, Call::Extern), make 520 src/Memoization.cpp stmt = LetStmt::make(let->name, value, body); make 508 src/Module.cpp IntImm::make(Int(32), 1) : make 509 src/Module.cpp Call::make(Int(32), "halide_can_use_target_features", make 510 src/Module.cpp {UIntImm::make(UInt(64), cur_target_mask)}, make 542 src/Module.cpp Expr indirect_result = Call::make(Int(32), Call::call_cached_indirect_function, wrapper_args, Call::Intrinsic); make 544 src/Module.cpp Expr private_result_var = Variable::make(Int(32), private_result_name); make 545 src/Module.cpp Stmt wrapper_body = AssertStmt::make(private_result_var == 0, private_result_var); make 546 src/Module.cpp wrapper_body = LetStmt::make(private_result_name, indirect_result, wrapper_body); make 127 src/ModulusRemainder.cpp Expr x = Variable::make(Int(32), "x"); make 128 src/ModulusRemainder.cpp Expr y = Variable::make(Int(32), "y"); make 136 src/ModulusRemainder.cpp check(Let::make("y", x*3 + 4, y*3 + 4), 9, 7); make 422 src/Monotonic.cpp Expr x = Variable::make(Int(32), "x"); make 423 src/Monotonic.cpp Expr y = Variable::make(Int(32), "y"); make 56 src/ParallelRVar.cpp expr = Variable::make(op->type, get_new_name(op->name)); make 114 src/ParallelRVar.cpp Expr distinct_v = (Variable::make(Int(32), v) != make 115 src/ParallelRVar.cpp Variable::make(Int(32), renamer.get_new_name(v))); make 124 src/Param.h min = Internal::Cast::make(type_of<T>(), min); make 131 src/Param.h max = Internal::Cast::make(type_of<T>(), max); make 148 src/Param.h return Internal::Variable::make(type_of<T>(), name(), param); make 170 src/Param.h return Internal::Variable::make(Handle(), "__user_context", make 305 src/Parameter.cpp return Variable::make(Int(32), s.str(), param); make 311 src/Parameter.cpp return Variable::make(Int(32), s.str(), param); make 321 src/Parameter.cpp return Variable::make(Int(32), s.str(), param); make 367 src/Parameter.cpp (*args)[i] = Cast::make(Int(32), (*args)[i]); make 72 src/PartitionLoops.cpp stmt = Store::make(op->name, value, index, op->param, predicate); make 366 src/PartitionLoops.cpp s.condition = Let::make(op->name, op->value, s.condition); make 608 src/PartitionLoops.cpp prologue_val = fold_left(min_vals, Max::make); make 612 src/PartitionLoops.cpp min_steady = Variable::make(Int(32), prologue_name); make 619 src/PartitionLoops.cpp epilogue_val = fold_left(max_vals, Min::make) + 1; make 627 src/PartitionLoops.cpp max_steady = Variable::make(Int(32), epilogue_name); make 634 src/PartitionLoops.cpp stmt = For::make(op->name, min_steady, max_steady - min_steady, make 638 src/PartitionLoops.cpp prologue = For::make(op->name, op->min, min_steady - op->min, make 640 src/PartitionLoops.cpp stmt = Block::make(prologue, stmt); make 643 src/PartitionLoops.cpp epilogue = For::make(op->name, max_steady, op->min + op->extent - max_steady, make 645 src/PartitionLoops.cpp stmt = Block::make(stmt, epilogue); make 651 src/PartitionLoops.cpp Expr loop_var = Variable::make(Int(32), op->name); make 654 src/PartitionLoops.cpp stmt = IfThenElse::make(min_steady <= loop_var && loop_var < max_steady, stmt, prologue); make 657 src/PartitionLoops.cpp stmt = IfThenElse::make(loop_var < max_steady, stmt, epilogue); make 660 src/PartitionLoops.cpp stmt = IfThenElse::make(loop_var < min_steady, prologue, stmt); make 663 src/PartitionLoops.cpp stmt = For::make(op->name, op->min, op->extent, op->for_type, op->device_api, stmt); make 669 src/PartitionLoops.cpp stmt = LetStmt::make(epilogue_name, epilogue_val, stmt); make 676 src/PartitionLoops.cpp stmt = LetStmt::make(prologue_name, prologue_val, stmt); make 751 src/PartitionLoops.cpp stmt = LetStmt::make(lifted_lets.back().first, make 773 src/PartitionLoops.cpp Expr new_var = Variable::make(op->value.type(), new_name); make 793 src/PartitionLoops.cpp Stmt inner = LetStmt::make(op->name, op->value, f->body); make 794 src/PartitionLoops.cpp inner = For::make(f->name, f->min, f->extent, f->for_type, f->device_api, inner); make 806 src/PartitionLoops.cpp Stmt inner = LetStmt::make(op->name, op->value, a->body); make 807 src/PartitionLoops.cpp inner = Allocate::make(a->name, a->type, a->extents, a->condition, inner); make 843 src/PartitionLoops.cpp Stmt inner = IfThenElse::make(op->condition, allocate_a->body, allocate_b->body); make 844 src/PartitionLoops.cpp inner = Allocate::make(allocate_a->name, allocate_a->type, allocate_a->extents, allocate_a->condition, inner); make 848 src/PartitionLoops.cpp Expr condition = Variable::make(op->condition.type(), condition_name); make 849 src/PartitionLoops.cpp Stmt inner = IfThenElse::make(condition, let_a->body, let_b->body); make 850 src/PartitionLoops.cpp inner = LetStmt::make(let_a->name, select(condition, let_a->value, let_b->value), inner); make 851 src/PartitionLoops.cpp inner = LetStmt::make(condition_name, op->condition, inner); make 856 src/PartitionLoops.cpp inner = substitute(let_a->name, Variable::make(let_a->value.type(), new_name), inner); make 857 src/PartitionLoops.cpp inner = IfThenElse::make(op->condition, inner, else_case); make 858 src/PartitionLoops.cpp inner = LetStmt::make(new_name, let_a->value, inner); make 863 src/PartitionLoops.cpp inner = substitute(let_b->name, Variable::make(let_b->value.type(), new_name), inner); make 864 src/PartitionLoops.cpp inner = IfThenElse::make(op->condition, then_case, inner); make 865 src/PartitionLoops.cpp inner = LetStmt::make(new_name, let_b->value, inner); make 871 src/PartitionLoops.cpp Stmt inner = IfThenElse::make(op->condition, for_a->body, for_b->body); make 872 src/PartitionLoops.cpp inner = For::make(for_a->name, for_a->min, for_a->extent, for_a->for_type, for_a->device_api, inner); make 898 src/PartitionLoops.cpp expr = mutate(Select::make(o->a, true_value, Select::make(o->b, true_value, false_value))); make 901 src/PartitionLoops.cpp Expr var = Variable::make(true_value.type(), var_name); make 902 src/PartitionLoops.cpp expr = mutate(Select::make(o->a, var, Select::make(o->b, var, false_value))); make 903 src/PartitionLoops.cpp expr = Let::make(var_name, true_value, expr); make 907 src/PartitionLoops.cpp expr = mutate(Select::make(a->a, Select::make(a->b, true_value, false_value), false_value)); make 910 src/PartitionLoops.cpp Expr var = Variable::make(false_value.type(), var_name); make 911 src/PartitionLoops.cpp expr = mutate(Select::make(a->a, Select::make(a->b, true_value, var), var)); make 912 src/PartitionLoops.cpp expr = Let::make(var_name, false_value, expr); make 915 src/PartitionLoops.cpp expr = mutate(Select::make(n->a, false_value, true_value)); make 921 src/PartitionLoops.cpp expr = Select::make(condition, true_value, false_value); make 964 src/PartitionLoops.cpp expr = Call::make(op->type, Call::likely, {mutate(op->args[0])}, Call::PureIntrinsic); make 86 src/Prefetch.cpp Expr buf_min_i = Variable::make(Int(32), name + ".min." + dim_name); make 87 src/Prefetch.cpp Expr buf_extent_i = Variable::make(Int(32), name + ".extent." + dim_name); make 129 src/Prefetch.cpp scope.push(op->name, Interval(Variable::make(op->value.type(), min_name), make 130 src/Prefetch.cpp Variable::make(op->value.type(), max_name))); make 140 src/Prefetch.cpp body = LetOrLetStmt::make(max_name, value_bounds.max, body); make 143 src/Prefetch.cpp body = LetOrLetStmt::make(min_name, value_bounds.min, body); make 146 src/Prefetch.cpp return LetOrLetStmt::make(op->name, op->value, body); make 176 src/Prefetch.cpp prefetch = Prefetch::make(buf_name, {param.type()}, bounds, param); make 180 src/Prefetch.cpp prefetch = Prefetch::make(buf_name, it->second.output_types(), bounds); make 184 src/Prefetch.cpp prefetch = IfThenElse::make(box.used, prefetch); make 186 src/Prefetch.cpp return Block::make({prefetch, body}); make 196 src/Prefetch.cpp Expr loop_var = Variable::make(Int(32), op->name); make 252 src/Prefetch.cpp stmt = For::make(op->name, op->min, op->extent, op->for_type, op->device_api, body); make 291 src/Prefetch.cpp new_offset += Variable::make(Int(32), index_name) * stride; make 299 src/Prefetch.cpp stmt = Evaluate::make(Call::make(call->type, Call::prefetch, args, Call::Intrinsic)); make 301 src/Prefetch.cpp stmt = For::make(index_names[i], 0, call->args[(i+max_dim)*2 + 2], make 345 src/Prefetch.cpp Expr outer_var = Variable::make(Int(32), index_name); make 354 src/Prefetch.cpp Expr abs_stride_bytes = Call::make(stride_bytes.type(), Call::abs, {stride_bytes}, Call::PureIntrinsic); make 362 src/Prefetch.cpp stmt = Evaluate::make(Call::make(call->type, Call::prefetch, args, Call::Intrinsic)); make 364 src/Prefetch.cpp stmt = For::make(index_names[i], 0, extents[i], make 99 src/Profiling.cpp size = simplify(Select::make(condition, size * type.bytes(), make_zero(UInt(64)))); make 142 src/Profiling.cpp stmt = Allocate::make(op->name, op->type, new_extents, condition, body, new_expr, op->free_function); make 146 src/Profiling.cpp Expr profiler_pipeline_state = Variable::make(Handle(), "profiler_pipeline_state"); make 148 src/Profiling.cpp Expr set_task = Call::make(Int(32), "halide_profiler_memory_allocate", make 150 src/Profiling.cpp stmt = Block::make(Evaluate::make(set_task), stmt); make 164 src/Profiling.cpp Expr profiler_pipeline_state = Variable::make(Handle(), "profiler_pipeline_state"); make 169 src/Profiling.cpp Expr set_task = Call::make(Int(32), "halide_profiler_memory_free", make 171 src/Profiling.cpp stmt = Block::make(Evaluate::make(set_task), stmt); make 199 src/Profiling.cpp Expr profiler_token = Variable::make(Int(32), "profiler_token"); make 200 src/Profiling.cpp Expr profiler_state = Variable::make(Handle(), "profiler_state"); make 203 src/Profiling.cpp Expr set_task = Call::make(Int(32), "halide_profiler_set_current_func", make 206 src/Profiling.cpp body = Block::make(Evaluate::make(set_task), body); make 208 src/Profiling.cpp stmt = ProducerConsumer::make(op->name, op->is_producer, body); make 221 src/Profiling.cpp Expr state = Variable::make(Handle(), "profiler_state"); make 223 src/Profiling.cpp Evaluate::make(Call::make(Int(32), "halide_profiler_incr_active_threads", make 226 src/Profiling.cpp Evaluate::make(Call::make(Int(32), "halide_profiler_decr_active_threads", make 230 src/Profiling.cpp body = Block::make({incr_active_threads, body, decr_active_threads}); make 247 src/Profiling.cpp Expr get_state = Call::make(Handle(), "halide_profiler_get_state", {}, Call::Extern); make 248 src/Profiling.cpp body = substitute("profiler_state", Variable::make(Handle(), "hvx_profiler_state"), body); make 249 src/Profiling.cpp body = LetStmt::make("hvx_profiler_state", get_state, body); make 257 src/Profiling.cpp stmt = For::make(op->name, op->min, op->extent, op->for_type, op->device_api, body); make 260 src/Profiling.cpp stmt = Block::make({decr_active_threads, stmt, incr_active_threads}); make 271 src/Profiling.cpp Expr func_names_buf = Variable::make(Handle(), "profiling_func_names"); make 273 src/Profiling.cpp Expr start_profiler = Call::make(Int(32), "halide_profiler_pipeline_start", make 276 src/Profiling.cpp Expr get_state = Call::make(Handle(), "halide_profiler_get_state", {}, Call::Extern); make 278 src/Profiling.cpp Expr get_pipeline_state = Call::make(Handle(), "halide_profiler_get_pipeline_state", {pipeline_name}, Call::Extern); make 280 src/Profiling.cpp Expr profiler_token = Variable::make(Int(32), "profiler_token"); make 282 src/Profiling.cpp Expr stop_profiler = Call::make(Int(32), Call::register_destructor, make 287 src/Profiling.cpp Expr func_stack_peak_buf = Variable::make(Handle(), "profiling_func_stack_peak_buf"); make 289 src/Profiling.cpp Expr profiler_pipeline_state = Variable::make(Handle(), "profiler_pipeline_state"); make 290 src/Profiling.cpp Stmt update_stack = Evaluate::make(Call::make(Int(32), "halide_profiler_stack_peak_update", make 292 src/Profiling.cpp s = Block::make(update_stack, s); make 295 src/Profiling.cpp Expr profiler_state = Variable::make(Handle(), "profiler_state"); make 297 src/Profiling.cpp Evaluate::make(Call::make(Int(32), "halide_profiler_incr_active_threads", make 300 src/Profiling.cpp Evaluate::make(Call::make(Int(32), "halide_profiler_decr_active_threads", make 302 src/Profiling.cpp s = Block::make({incr_active_threads, s, decr_active_threads}); make 304 src/Profiling.cpp s = LetStmt::make("profiler_pipeline_state", get_pipeline_state, s); make 305 src/Profiling.cpp s = LetStmt::make("profiler_state", get_state, s); make 309 src/Profiling.cpp s = Block::make(AssertStmt::make(profiler_token >= 0, profiler_token), s); make 310 src/Profiling.cpp s = LetStmt::make("profiler_token", start_profiler, s); make 314 src/Profiling.cpp s = Block::make(Store::make("profiling_func_stack_peak_buf", make 318 src/Profiling.cpp s = Block::make(s, Free::make("profiling_func_stack_peak_buf")); make 319 src/Profiling.cpp s = Allocate::make("profiling_func_stack_peak_buf", UInt(64), {num_funcs}, const_true(), s); make 323 src/Profiling.cpp s = Block::make(Store::make("profiling_func_names", p.first, p.second, Parameter(), const_true()), s); make 326 src/Profiling.cpp s = Block::make(s, Free::make("profiling_func_names")); make 327 src/Profiling.cpp s = Allocate::make("profiling_func_names", Handle(), {num_funcs}, const_true(), s); make 328 src/Profiling.cpp s = Block::make(Evaluate::make(stop_profiler), s); make 19 src/Qualify.cpp expr = Variable::make(v->type, prefix + v->name, v->reduction_domain); make 25 src/Qualify.cpp expr = Let::make(prefix + op->name, value, body); make 21 src/RDom.cpp return Variable::make(Int(32), name(), domain()); make 81 src/Random.cpp result = Let::make(name, result + cast<uint32_t>(e[i]), make 82 src/Random.cpp rng32(Variable::make(UInt(32), name))); make 123 src/Random.cpp extra_args.push_back(Variable::make(Int(32), free_vars[i])); make 167 src/Reduction.cpp expr = Variable::make(op->type, op->name); make 57 src/RemoveDeadAllocations.cpp stmt = Allocate::make(op->name, op->type, op->extents, op->condition, body, op->new_expr, op->free_function); make 64 src/RemoveDeadAllocations.cpp stmt = Evaluate::make(0); make 34 src/RemoveTrivialForLoops.cpp stmt = LetStmt::make(for_loop->name, for_loop->min, body); make 36 src/RemoveTrivialForLoops.cpp stmt = Evaluate::make(0); make 39 src/RemoveTrivialForLoops.cpp stmt = LetStmt::make(for_loop->name, for_loop->min, body); make 40 src/RemoveTrivialForLoops.cpp stmt = IfThenElse::make(for_loop->extent > 0, stmt, Stmt()); make 44 src/RemoveTrivialForLoops.cpp stmt = For::make(for_loop->name, for_loop->min, for_loop->extent, for_loop->for_type, for_loop->device_api, body); make 39 src/RemoveUndef.cpp expr = T::make(a, b); make 50 src/RemoveUndef.cpp expr = Cast::make(op->type, value); make 76 src/RemoveUndef.cpp else expr = Not::make(a); make 97 src/RemoveUndef.cpp cond = Not::make(cond); make 115 src/RemoveUndef.cpp expr = Select::make(cond, t, f); make 126 src/RemoveUndef.cpp expr = Load::make(op->type, op->name, index, op->image, op->param, pred); make 139 src/RemoveUndef.cpp expr = Ramp::make(base, stride, op->lanes); make 147 src/RemoveUndef.cpp else expr = Broadcast::make(value, op->lanes); make 171 src/RemoveUndef.cpp expr = Call::make(op->type, op->name, new_args, op->call_type, make 192 src/RemoveUndef.cpp expr = Let::make(op->name, value, body); make 213 src/RemoveUndef.cpp stmt = LetStmt::make(op->name, value, body); make 233 src/RemoveUndef.cpp stmt = AssertStmt::make(condition, message); make 243 src/RemoveUndef.cpp stmt = ProducerConsumer::make(op->name, op->is_producer, body); make 265 src/RemoveUndef.cpp stmt = For::make(op->name, min, extent, op->for_type, op->device_api, body); make 287 src/RemoveUndef.cpp stmt = IfThenElse::make(predicate, Store::make(op->name, value, index, op->param, pred)); make 294 src/RemoveUndef.cpp stmt = Store::make(op->name, value, index, op->param, pred); make 356 src/RemoveUndef.cpp stmt = IfThenElse::make(predicate, Provide::make(op->name, new_values, new_args)); make 361 src/RemoveUndef.cpp stmt = Provide::make(op->name, new_values, new_args); make 393 src/RemoveUndef.cpp stmt = Allocate::make(op->name, op->type, new_extents, condition, body, new_expr, op->free_function); make 435 src/RemoveUndef.cpp stmt = Realize::make(op->name, op->types, new_bounds, condition, body); make 450 src/RemoveUndef.cpp stmt = Block::make(first, rest); make 469 src/RemoveUndef.cpp condition = Not::make(condition); make 479 src/RemoveUndef.cpp stmt = IfThenElse::make(condition, then_case, else_case); make 490 src/RemoveUndef.cpp stmt = Evaluate::make(v); make 76 src/ScheduleFunctions.cpp Stmt stmt = Provide::make(func_name, values, site); make 108 src/ScheduleFunctions.cpp stmt = LetStmt::make(res.name, res.value, stmt); make 111 src/ScheduleFunctions.cpp stmt = IfThenElse::make(res.value, stmt, Stmt()); make 204 src/ScheduleFunctions.cpp stmt = LetStmt::make(nest[i].name, nest[i].value, stmt); make 207 src/ScheduleFunctions.cpp stmt = IfThenElse::make(nest[i].value, stmt, Stmt()); make 211 src/ScheduleFunctions.cpp Expr min = Variable::make(Int(32), nest[i].name + ".loop_min"); make 212 src/ScheduleFunctions.cpp Expr extent = Variable::make(Int(32), nest[i].name + ".loop_extent"); make 213 src/ScheduleFunctions.cpp stmt = For::make(nest[i].name, min, extent, dim.for_type, dim.device_api, stmt); make 225 src/ScheduleFunctions.cpp stmt = LetStmt::make(let_stmts[j].first, let_stmts[j].second, stmt); make 232 src/ScheduleFunctions.cpp stmt = LetStmt::make(o + ".loop_min", 0, stmt); make 233 src/ScheduleFunctions.cpp stmt = LetStmt::make(o + ".loop_max", 0, stmt); make 234 src/ScheduleFunctions.cpp stmt = LetStmt::make(o + ".loop_extent", 1, stmt); make 240 src/ScheduleFunctions.cpp Expr max = Variable::make(Int(32), var + ".max"); make 241 src/ScheduleFunctions.cpp Expr min = Variable::make(Int(32), var + ".min"); // Inject instance name here? (compute instance names during lowering) make 242 src/ScheduleFunctions.cpp stmt = LetStmt::make(var + ".loop_extent", make 245 src/ScheduleFunctions.cpp stmt = LetStmt::make(var + ".loop_min", min, stmt); make 246 src/ScheduleFunctions.cpp stmt = LetStmt::make(var + ".loop_max", max, stmt); make 253 src/ScheduleFunctions.cpp Expr rmin = Variable::make(Int(32), p + ".min"); make 254 src/ScheduleFunctions.cpp Expr rmax = Variable::make(Int(32), p + ".max"); make 255 src/ScheduleFunctions.cpp stmt = LetStmt::make(p + ".loop_min", rmin, stmt); make 256 src/ScheduleFunctions.cpp stmt = LetStmt::make(p + ".loop_max", rmax, stmt); make 257 src/ScheduleFunctions.cpp stmt = LetStmt::make(p + ".loop_extent", rmax - rmin + 1, stmt); make 308 src/ScheduleFunctions.cpp Internal::Call::make(Int(32), make 310 src/ScheduleFunctions.cpp {StringImm::make(s.failure_message)}, make 312 src/ScheduleFunctions.cpp then_case = AssertStmt::make(const_false(), specialize_fail_error); make 314 src/ScheduleFunctions.cpp stmt = IfThenElse::make(c, then_case, stmt); make 355 src/ScheduleFunctions.cpp Expr buffer = Variable::make(type_of<struct halide_buffer_t *>(), buf_name); make 364 src/ScheduleFunctions.cpp Expr buf = Variable::make(type_of<struct halide_buffer_t *>(), b.name() + ".buffer", p); make 370 src/ScheduleFunctions.cpp Expr buf = Variable::make(type_of<struct halide_buffer_t *>(), p.name() + ".buffer", p); make 394 src/ScheduleFunctions.cpp Expr buffer = Variable::make(type_of<struct halide_buffer_t *>(), buf_name); make 415 src/ScheduleFunctions.cpp Expr src_buffer = Variable::make(type_of<struct halide_buffer_t *>(), src_buf_name); make 417 src/ScheduleFunctions.cpp Expr alloca_size = Call::make(Int(32), Call::size_of_halide_buffer_t, {}, Call::Intrinsic); make 418 src/ScheduleFunctions.cpp Expr output_buffer_t = Call::make(type_of<struct halide_buffer_t *>(), Call::alloca, make 423 src/ScheduleFunctions.cpp args[1] = Call::make(type_of<struct halide_dimension_t *>(), Call::alloca, make 431 src/ScheduleFunctions.cpp Expr min = Variable::make(Int(32), var + ".min"); make 432 src/ScheduleFunctions.cpp Expr max = Variable::make(Int(32), var + ".max"); make 436 src/ScheduleFunctions.cpp args[3] = Call::make(Handle(), Call::make_struct, mins, Call::Intrinsic); make 437 src/ScheduleFunctions.cpp args[4] = Call::make(Handle(), Call::make_struct, extents, Call::Intrinsic); make 439 src/ScheduleFunctions.cpp output_buffer_t = Call::make(type_of<struct halide_buffer_t *>(), Call::buffer_crop, args, Call::Extern); make 442 src/ScheduleFunctions.cpp extern_call_args.push_back(Variable::make(type_of<struct halide_buffer_t *>(), buf_name)); make 458 src/ScheduleFunctions.cpp Expr sizeof_buffer_t = cast<uint64_t>(Call::make(Int(32), Call::size_of_halide_buffer_t, {}, Call::Intrinsic)); make 460 src/ScheduleFunctions.cpp Evaluate::make(Call::make(Int(32), "halide_msan_annotate_memory_is_initialized", make 462 src/ScheduleFunctions.cpp Expr shape = Call::make(type_of<halide_dimension_t *>(), Call::buffer_get_shape, {buffer}, Call::Extern); make 465 src/ScheduleFunctions.cpp Evaluate::make(Call::make(Int(32), "halide_msan_annotate_memory_is_initialized", make 467 src/ScheduleFunctions.cpp mark_buffer = Block::make(mark_buffer, mark_shape); make 469 src/ScheduleFunctions.cpp annotate = Block::make(annotate, mark_buffer); make 477 src/ScheduleFunctions.cpp Stmt mark_contents = Evaluate::make(Call::make(Int(32), "halide_msan_annotate_buffer_is_initialized", {buffer}, Call::Extern)); make 479 src/ScheduleFunctions.cpp annotate = Block::make(annotate, mark_contents); make 491 src/ScheduleFunctions.cpp Expr result = Variable::make(Int(32), result_name); make 492 src/ScheduleFunctions.cpp Expr error = Call::make(Int(32), "halide_error_extern_stage_failed", make 494 src/ScheduleFunctions.cpp Stmt check = AssertStmt::make(EQ::make(result, 0), error); make 495 src/ScheduleFunctions.cpp check = LetStmt::make(result_name, e, check); make 498 src/ScheduleFunctions.cpp check = LetStmt::make(lets[i].first, lets[i].second, check); make 502 src/ScheduleFunctions.cpp check = Block::make(annotate, check); make 536 src/ScheduleFunctions.cpp Stmt merged_updates = Block::make(updates); make 551 src/ScheduleFunctions.cpp Expr min_var = Variable::make(Int(32), min_name); make 552 src/ScheduleFunctions.cpp Expr max_var = Variable::make(Int(32), max_name); make 565 src/ScheduleFunctions.cpp Expr error_msg = Call::make(Int(32), "halide_error_explicit_bounds_too_small", make 568 src/ScheduleFunctions.cpp body = Block::make(AssertStmt::make(check, error_msg), body); make 629 src/ScheduleFunctions.cpp producer = Block::make(realization.first, realization.second); make 648 src/ScheduleFunctions.cpp return Block::make(producer, consumer); make 659 src/ScheduleFunctions.cpp Expr min = Variable::make(Int(32), name + "." + arg + ".min_realized"); make 660 src/ScheduleFunctions.cpp Expr extent = Variable::make(Int(32), name + "." + arg + ".extent_realized"); make 664 src/ScheduleFunctions.cpp s = Realize::make(name, func.output_types(), bounds, const_true(), s); make 688 src/ScheduleFunctions.cpp stmt = ProducerConsumer::make(op->name, op->is_producer, body); make 746 src/ScheduleFunctions.cpp body = LetStmt::make(lets[i - 1].first, lets[i - 1].second, body); make 752 src/ScheduleFunctions.cpp stmt = For::make(for_loop->name, make 1152 src/ScheduleFunctions.cpp Stmt s = For::make(root_var, 0, 1, ForType::Serial, DeviceAPI::Host, Evaluate::make(0)); make 12 src/ScheduleParam.cpp scalar_expr(Variable::make(t, scalar_parameter.name() + ".schedule_param_var", scalar_parameter)), make 30 src/SelectGPUAPI.cpp stmt = For::make(op->name, op->min, op->extent, op->for_type, selected_api, op->body); make 98 src/Simplify.cpp return Call::make(t, Call::signed_integer_overflow, {counter++}, Call::Intrinsic); make 106 src/Simplify.cpp return Call::make(t, Call::indeterminate_expression, {counter++}, Call::Intrinsic); make 484 src/Simplify.cpp expr = IntImm::make(op->type, (int64_t)f); make 488 src/Simplify.cpp expr = UIntImm::make(op->type, (uint64_t)f); make 492 src/Simplify.cpp expr = FloatImm::make(op->type, f); make 496 src/Simplify.cpp expr = IntImm::make(op->type, i); make 500 src/Simplify.cpp expr = UIntImm::make(op->type, (uint64_t)i); make 504 src/Simplify.cpp expr = FloatImm::make(op->type, (double)i); make 508 src/Simplify.cpp expr = IntImm::make(op->type, (int64_t)u); make 512 src/Simplify.cpp expr = UIntImm::make(op->type, u); make 516 src/Simplify.cpp expr = FloatImm::make(op->type, (double)u); make 523 src/Simplify.cpp expr = mutate(Cast::make(op->type, cast->value)); make 534 src/Simplify.cpp expr = mutate(Cast::make(op->type, cast->value)); make 537 src/Simplify.cpp expr = mutate(Broadcast::make(Cast::make(op->type.element_of(), broadcast_value->value), broadcast_value->lanes)); make 542 src/Simplify.cpp expr = mutate(Ramp::make(Cast::make(op->type.element_of(), ramp_value->base), make 543 src/Simplify.cpp Cast::make(op->type.element_of(), ramp_value->stride), make 551 src/Simplify.cpp expr = mutate(Cast::make(op->type, add->a) + add->b); make 555 src/Simplify.cpp expr = Cast::make(op->type, value); make 657 src/Simplify.cpp expr = IntImm::make(a.type(), ia + ib); make 662 src/Simplify.cpp expr = UIntImm::make(a.type(), ua + ub); make 666 src/Simplify.cpp expr = FloatImm::make(a.type(), fa + fb); make 686 src/Simplify.cpp expr = hoist_slice_vector<Add>(Add::make(a, b)); make 691 src/Simplify.cpp expr = mutate(Ramp::make(ramp_a->base + ramp_b->base, make 696 src/Simplify.cpp expr = mutate(Ramp::make(ramp_a->base + broadcast_b->value, make 701 src/Simplify.cpp expr = mutate(Ramp::make(broadcast_a->value + ramp_b->base, make 706 src/Simplify.cpp expr = Broadcast::make(mutate(broadcast_a->value + broadcast_b->value), make 713 src/Simplify.cpp expr = mutate(Select::make(select_a->condition, make 721 src/Simplify.cpp expr = mutate(Select::make(select_a->condition, make 805 src/Simplify.cpp expr = mutate(Min::make(Add::make(min_a->a, b), sub_a_b->a)); make 811 src/Simplify.cpp expr = mutate(Min::make(sub_a_a->a, Add::make(min_a->b, b))); make 817 src/Simplify.cpp expr = mutate(Max::make(Add::make(max_a->a, b), sub_a_b->a)); make 823 src/Simplify.cpp expr = mutate(Max::make(sub_a_a->a, Add::make(max_a->b, b))); make 832 src/Simplify.cpp expr = mutate(Min::make(Add::make(min_a->a, b), add_a_b->a)); make 840 src/Simplify.cpp expr = mutate(Min::make(add_a_a->a, Add::make(min_a->b, b))); make 848 src/Simplify.cpp expr = mutate(Max::make(Add::make(max_a->a, b), add_a_b->a)); make 856 src/Simplify.cpp expr = mutate(Max::make(add_a_a->a, Add::make(max_a->b, b))); make 876 src/Simplify.cpp expr = mutate((add_a_a->a + IntImm::make(op->type, ia + ib*ic)) / div_a->b); make 951 src/Simplify.cpp expr = Add::make(a, b); make 1021 src/Simplify.cpp expr = IntImm::make(a.type(), ia - ib); make 1024 src/Simplify.cpp expr = UIntImm::make(a.type(), ua - ub); make 1026 src/Simplify.cpp expr = FloatImm::make(a.type(), fa - fb); make 1028 src/Simplify.cpp expr = mutate(a + IntImm::make(a.type(), (-ib))); make 1030 src/Simplify.cpp expr = mutate(a + FloatImm::make(a.type(), (-fb))); make 1039 src/Simplify.cpp expr = mutate(Ramp::make(ramp_a->base - ramp_b->base, make 1043 src/Simplify.cpp expr = mutate(Ramp::make(ramp_a->base - broadcast_b->value, make 1047 src/Simplify.cpp expr = mutate(Ramp::make(broadcast_a->value - ramp_b->base, make 1052 src/Simplify.cpp expr = Broadcast::make(mutate(broadcast_a->value - broadcast_b->value), make 1057 src/Simplify.cpp expr = mutate(Select::make(select_a->condition, make 1063 src/Simplify.cpp expr = mutate(Select::make(select_a->condition, make 1069 src/Simplify.cpp expr = mutate(Select::make(select_a->condition, make 1075 src/Simplify.cpp expr = mutate(Select::make(select_b->condition, make 1081 src/Simplify.cpp expr = mutate(Select::make(select_b->condition, make 1102 src/Simplify.cpp expr = mutate(Max::make(make_zero(op->type), max_a->b - max_a->a)); make 1108 src/Simplify.cpp expr = mutate(Min::make(make_zero(op->type), min_a->b - min_a->a)); make 1114 src/Simplify.cpp expr = mutate(Max::make(max_a->a - max_a->b, make_zero(op->type))); make 1120 src/Simplify.cpp expr = mutate(Min::make(min_a->a - min_a->b, make_zero(op->type))); make 1127 src/Simplify.cpp expr = mutate(Min::make(make_zero(op->type), max_b->a - max_b->b)); make 1133 src/Simplify.cpp expr = mutate(Max::make(make_zero(op->type), min_b->a - min_b->b)); make 1139 src/Simplify.cpp expr = mutate(Min::make(max_b->b - max_b->a, make_zero(op->type))); make 1145 src/Simplify.cpp expr = mutate(Max::make(min_b->b - min_b->a, make_zero(op->type))); make 1442 src/Simplify.cpp expr = Sub::make(a, b); make 1490 src/Simplify.cpp expr = IntImm::make(a.type(), ia * ib); make 1493 src/Simplify.cpp expr = UIntImm::make(a.type(), ua * ub); make 1495 src/Simplify.cpp expr = FloatImm::make(a.type(), fa * fb); make 1508 src/Simplify.cpp expr = hoist_slice_vector<Mul>(Mul::make(a, b)); make 1511 src/Simplify.cpp expr = Broadcast::make(mutate(broadcast_a->value * broadcast_b->value), broadcast_a->lanes); make 1514 src/Simplify.cpp expr = mutate(Ramp::make(ramp_a->base * m, ramp_a->stride * m, ramp_a->lanes)); make 1517 src/Simplify.cpp expr = mutate(Ramp::make(m * ramp_b->base, m * ramp_b->stride, ramp_b->lanes)); make 1524 src/Simplify.cpp expr = mutate(Mul::make(Sub::make(sub_a->b, sub_a->a), -b)); make 1545 src/Simplify.cpp expr = Mul::make(a, b); make 1640 src/Simplify.cpp expr = IntImm::make(op->type, div_imp(ia, ib)); make 1643 src/Simplify.cpp expr = UIntImm::make(op->type, ua / ub); make 1647 src/Simplify.cpp expr = FloatImm::make(op->type, fa / fb); make 1649 src/Simplify.cpp expr = mutate(Broadcast::make(Div::make(broadcast_a->value, broadcast_b->value), broadcast_a->lanes)); make 1665 src/Simplify.cpp expr = mutate(Ramp::make(ramp_a->base / broadcast_b->value, make 1666 src/Simplify.cpp IntImm::make(t, div_imp(ia, ib)), make 1677 src/Simplify.cpp expr = mutate(Broadcast::make(ramp_a->base / broadcast_b->value, ramp_a->lanes)); make 1968 src/Simplify.cpp expr = Div::make(a, b); make 2023 src/Simplify.cpp expr = IntImm::make(op->type, mod_imp(ia, ib)); make 2025 src/Simplify.cpp expr = UIntImm::make(op->type, ua % ub); make 2027 src/Simplify.cpp expr = FloatImm::make(op->type, mod_imp(fa, fb)); make 2029 src/Simplify.cpp expr = mutate(Broadcast::make(Mod::make(broadcast_a->value, broadcast_b->value), broadcast_a->lanes)); make 2078 src/Simplify.cpp expr = mutate(Broadcast::make(ramp_a->base % broadcast_b->value, ramp_a->lanes)); make 2089 src/Simplify.cpp expr = mutate(Ramp::make(new_base, ramp_a->stride, ramp_a->lanes)); make 2101 src/Simplify.cpp expr = mutate(Ramp::make(new_base, ramp_a->stride, ramp_a->lanes) % b); make 2105 src/Simplify.cpp expr = Mod::make(a, b); make 2169 src/Simplify.cpp expr = IntImm::make(op->type, std::min(ia, ib)); make 2173 src/Simplify.cpp expr = UIntImm::make(op->type, std::min(ua, ub)); make 2177 src/Simplify.cpp expr = FloatImm::make(op->type, std::min(fa, fb)); make 2201 src/Simplify.cpp expr = mutate(Broadcast::make(Min::make(broadcast_a->value, broadcast_b->value), broadcast_a->lanes)); make 2322 src/Simplify.cpp expr = mutate(Min::make(min_a->a, Broadcast::make(Min::make(broadcast_a_b->value, broadcast_b->value), broadcast_b->lanes))); make 2343 src/Simplify.cpp expr = mutate(Max::make(Min::make(max_a->b, max_b->b), max_a->a)); make 2348 src/Simplify.cpp expr = mutate(Max::make(Min::make(max_a->b, max_b->a), max_a->a)); make 2353 src/Simplify.cpp expr = mutate(Max::make(Min::make(max_a->a, max_b->b), max_a->b)); make 2358 src/Simplify.cpp expr = mutate(Max::make(Min::make(max_a->a, max_b->a), max_a->b)); make 2363 src/Simplify.cpp expr = mutate(Min::make(Min::make(min_a->b, min_b->b), min_a->a)); make 2368 src/Simplify.cpp expr = mutate(Min::make(Min::make(min_a->b, min_b->a), min_a->a)); make 2373 src/Simplify.cpp expr = mutate(Min::make(Min::make(min_a->a, min_b->b), min_a->b)); make 2378 src/Simplify.cpp expr = mutate(Min::make(Min::make(min_a->a, min_b->a), min_a->b)); make 2418 src/Simplify.cpp expr = Min::make(min_a->a, mutate(Min::make(b, min_a->b))); make 2421 src/Simplify.cpp expr = mutate(Min::make(Min::make(min_a->a, b), min_a->b)); make 2496 src/Simplify.cpp expr = Min::make(a, b); make 2554 src/Simplify.cpp expr = IntImm::make(op->type, std::max(ia, ib)); make 2558 src/Simplify.cpp expr = UIntImm::make(op->type, std::max(ua, ub)); make 2562 src/Simplify.cpp expr = FloatImm::make(op->type, std::max(fa, fb)); make 2585 src/Simplify.cpp expr = mutate(Broadcast::make(Max::make(broadcast_a->value, broadcast_b->value), broadcast_a->lanes)); make 2687 src/Simplify.cpp expr = mutate(Max::make(max_a->a, Broadcast::make(Max::make(broadcast_a_b->value, broadcast_b->value), broadcast_b->lanes))); make 2706 src/Simplify.cpp expr = mutate(Max::make(Max::make(max_a->b, max_b->b), max_a->a)); make 2711 src/Simplify.cpp expr = mutate(Max::make(Max::make(max_a->b, max_b->a), max_a->a)); make 2716 src/Simplify.cpp expr = mutate(Max::make(Max::make(max_a->a, max_b->b), max_a->b)); make 2721 src/Simplify.cpp expr = mutate(Max::make(Max::make(max_a->a, max_b->a), max_a->b)); make 2726 src/Simplify.cpp expr = mutate(Min::make(Max::make(min_a->b, min_b->b), min_a->a)); make 2731 src/Simplify.cpp expr = mutate(Min::make(Max::make(min_a->b, min_b->a), min_a->a)); make 2736 src/Simplify.cpp expr = mutate(Min::make(Max::make(min_a->a, min_b->b), min_a->b)); make 2741 src/Simplify.cpp expr = mutate(Min::make(Max::make(min_a->a, min_b->a), min_a->b)); make 2780 src/Simplify.cpp expr = Max::make(max_a->a, mutate(Max::make(b, max_a->b))); make 2783 src/Simplify.cpp expr = mutate(Max::make(Max::make(max_a->a, b), max_a->b)); make 2858 src/Simplify.cpp expr = Max::make(a, b); make 2916 src/Simplify.cpp expr = Broadcast::make(mutate(broadcast->value == make 2956 src/Simplify.cpp expr = mutate(Not::make(op->a == op->b)); make 3038 src/Simplify.cpp expr = mutate(Broadcast::make(broadcast_a->value < broadcast_b->value, broadcast_a->lanes)); make 3045 src/Simplify.cpp expr = mutate(Broadcast::make(bases_lt, ramp_a->lanes)); make 3144 src/Simplify.cpp expr = LT::make(a, b); make 3155 src/Simplify.cpp expr = LT::make(a, b); make 3166 src/Simplify.cpp expr = LT::make(a, b); make 3177 src/Simplify.cpp expr = LT::make(a, b); make 3270 src/Simplify.cpp expr = Broadcast::make(mutate(LT::make(delta_ramp->base / mod_rem.modulus, 0)), delta_ramp->lanes); make 3274 src/Simplify.cpp expr = LT::make(a, b); make 3279 src/Simplify.cpp expr = LT::make(a, b); make 3452 src/Simplify.cpp expr = mutate(And::make(a, NE::make(eq_a->b, neq_b->b))); make 3460 src/Simplify.cpp expr = mutate(And::make(b, NE::make(neq_a->b, eq_b->b))); make 3466 src/Simplify.cpp expr = mutate(And::make(a, substitute(eq_a->a.as<Variable>(), eq_a->b, b))); make 3472 src/Simplify.cpp expr = mutate(And::make(substitute(eq_b->a.as<Variable>(), eq_b->b, a), b)); make 3477 src/Simplify.cpp expr = Broadcast::make(mutate(And::make(broadcast_a->value, broadcast_b->value)), broadcast_a->lanes); make 3486 src/Simplify.cpp expr = And::make(a, b); make 3622 src/Simplify.cpp expr = Broadcast::make(mutate(Or::make(broadcast_a->value, broadcast_b->value)), broadcast_a->lanes); make 3630 src/Simplify.cpp expr = mutate(Or::make(b, EQ::make(eq_a->b, neq_b->b))); make 3638 src/Simplify.cpp expr = mutate(Or::make(a, EQ::make(neq_a->b, eq_b->b))); make 3651 src/Simplify.cpp expr = mutate(And::make(Or::make(and_a->a, b), Or::make(and_a->b, b))); make 3660 src/Simplify.cpp expr = mutate(And::make(Or::make(and_b->a, a), Or::make(and_b->b, a))); make 3664 src/Simplify.cpp expr = Or::make(a, b); make 3682 src/Simplify.cpp expr = LT::make(n->b, n->a); make 3684 src/Simplify.cpp expr = LT::make(n->a, n->b); make 3686 src/Simplify.cpp expr = LE::make(n->b, n->a); make 3688 src/Simplify.cpp expr = LE::make(n->a, n->b); make 3690 src/Simplify.cpp expr = EQ::make(n->a, n->b); make 3692 src/Simplify.cpp expr = NE::make(n->a, n->b); make 3694 src/Simplify.cpp expr = mutate(Broadcast::make(!n->value, n->lanes)); make 3698 src/Simplify.cpp expr = Not::make(a); make 3731 src/Simplify.cpp expr = Broadcast::make(condition, true_value.type().lanes()); make 3739 src/Simplify.cpp expr = Broadcast::make(mutate(!condition), true_value.type().lanes()); make 3745 src/Simplify.cpp expr = mutate(Select::make(b->value, true_value, false_value)); make 3748 src/Simplify.cpp expr = mutate(Select::make(ne->a == ne->b, false_value, true_value)); make 3751 src/Simplify.cpp expr = mutate(Select::make(le->b < le->a, false_value, true_value)); make 3764 src/Simplify.cpp expr = mutate(Select::make(condition && !sel_t->condition, sel_t->false_value, false_value)); make 3768 src/Simplify.cpp expr = mutate(Select::make(condition && sel_t->condition, sel_t->true_value, false_value)); make 3772 src/Simplify.cpp expr = mutate(Select::make(condition || !sel_f->condition, true_value, sel_f->true_value)); make 3776 src/Simplify.cpp expr = mutate(Select::make(condition || sel_f->condition, true_value, sel_f->false_value)); make 3781 src/Simplify.cpp expr = mutate(add_t->a + Select::make(condition, add_t->b, add_f->b)); make 3786 src/Simplify.cpp expr = mutate(add_t->a + Select::make(condition, add_t->b, add_f->a)); make 3791 src/Simplify.cpp expr = mutate(add_t->b + Select::make(condition, add_t->a, add_f->b)); make 3796 src/Simplify.cpp expr = mutate(Select::make(condition, add_t->a, add_f->a) + add_t->b); make 3801 src/Simplify.cpp expr = mutate(sub_t->a - Select::make(condition, sub_t->b, sub_f->b)); make 3806 src/Simplify.cpp expr = mutate(Select::make(condition, sub_t->a, sub_f->a) - sub_t->b);\ make 3811 src/Simplify.cpp expr = mutate(add_t->a + Select::make(condition, add_t->b, make_zero(sub_f->b.type()) - sub_f->b)); make 3816 src/Simplify.cpp expr = mutate(add_t->b + Select::make(condition, add_t->a, make_zero(sub_f->b.type()) - sub_f->b)); make 3821 src/Simplify.cpp expr = mutate(sub_t->a + Select::make(condition, make_zero(sub_t->b.type()) - sub_t->b, add_f->b)); make 3826 src/Simplify.cpp expr = mutate(sub_t->a + Select::make(condition, make_zero(sub_t->b.type()) - sub_t->b, add_f->a)); make 3831 src/Simplify.cpp expr = mutate(mul_t->a * Select::make(condition, mul_t->b, mul_f->b)); make 3836 src/Simplify.cpp expr = mutate(mul_t->a * Select::make(condition, mul_t->b, mul_f->a)); make 3841 src/Simplify.cpp expr = mutate(mul_t->b * Select::make(condition, mul_t->a, mul_f->b)); make 3846 src/Simplify.cpp expr = mutate(Select::make(condition, mul_t->a, mul_f->a) * mul_t->b); make 3852 src/Simplify.cpp expr = Select::make(condition, true_value, false_value); make 3861 src/Simplify.cpp expr = Broadcast::make(base, op->lanes); make 3866 src/Simplify.cpp expr = Ramp::make(base, stride, op->lanes); make 3884 src/Simplify.cpp stmt = Evaluate::make(0); make 3971 src/Simplify.cpp stmt = IfThenElse::make(condition, then_case, else_case); make 3988 src/Simplify.cpp Expr load = Load::make(op->type.element_of(), op->name, b_index->value, op->image, op->param, b_pred->value); make 3989 src/Simplify.cpp expr = Broadcast::make(load, b_index->lanes); make 3993 src/Simplify.cpp expr = Load::make(op->type, op->name, index, op->image, op->param, predicate); make 4025 src/Simplify.cpp expr = mutate(Mul::make(a, b)); make 4027 src/Simplify.cpp expr = mutate(Div::make(a, b)); make 4056 src/Simplify.cpp expr = Mod::make(a, make_const(a.type(), ib + 1)); make 4062 src/Simplify.cpp expr = Mod::make(a, make_const(a.type(), ub + 1)); make 4114 src/Simplify.cpp expr = Call::make(op->type, op->name, {arg}, op->call_type); make 4162 src/Simplify.cpp expr = Call::make(op->type, op->name, new_args, op->call_type); make 4173 src/Simplify.cpp expr = FloatImm::make(arg.type(), std::sqrt(*f)); make 4175 src/Simplify.cpp expr = Call::make(op->type, op->name, {arg}, op->call_type); make 4186 src/Simplify.cpp expr = FloatImm::make(arg.type(), std::log(*f)); make 4188 src/Simplify.cpp expr = Call::make(op->type, op->name, {arg}, op->call_type); make 4199 src/Simplify.cpp expr = FloatImm::make(arg.type(), std::exp(*f)); make 4201 src/Simplify.cpp expr = Call::make(op->type, op->name, {arg}, op->call_type); make 4215 src/Simplify.cpp expr = FloatImm::make(arg0.type(), std::pow(*f0, *f1)); make 4217 src/Simplify.cpp expr = Call::make(op->type, op->name, {arg0, arg1}, op->call_type); make 4232 src/Simplify.cpp expr = FloatImm::make(arg.type(), std::floor(*f)); make 4234 src/Simplify.cpp expr = FloatImm::make(arg.type(), std::ceil(*f)); make 4236 src/Simplify.cpp expr = FloatImm::make(arg.type(), std::nearbyint(*f)); make 4238 src/Simplify.cpp expr = FloatImm::make(arg.type(), (*f < 0 ? std::ceil(*f) : std::floor(*f))); make 4247 src/Simplify.cpp expr = Call::make(op->type, op->name, {arg}, op->call_type); make 4291 src/Simplify.cpp expr = Call::make(op->type, Call::prefetch, args, Call::Intrinsic); make 4346 src/Simplify.cpp Expr shuffled_index = Shuffle::make(load_indices, op->indices); make 4353 src/Simplify.cpp shuffled_predicate = Shuffle::make(load_predicates, op->indices); make 4358 src/Simplify.cpp expr = Load::make(t, first_load->name, shuffled_index, first_load->image, make 4383 src/Simplify.cpp expr = Broadcast::make(b1->value, op->indices.size()); make 4413 src/Simplify.cpp expr = Ramp::make(r->base, mutate(r->stride / terms), r->lanes * terms); make 4479 src/Simplify.cpp expr = Ramp::make(r->base, r->stride, op->indices.size()); make 4501 src/Simplify.cpp expr = Ramp::make(new_vectors[0], stride, op->indices.size()); make 4510 src/Simplify.cpp expr = Shuffle::make(new_vectors, op->indices); make 4544 src/Simplify.cpp new_slices.push_back(T::make(slices_a[i], slices_b[i])); make 4547 src/Simplify.cpp return Shuffle::make(new_slices, shuffle_a->indices); make 4563 src/Simplify.cpp Expr new_var = Variable::make(new_value.type(), new_name); make 4603 src/Simplify.cpp replacement = substitute(new_name, Add::make(new_var, add->b), replacement); make 4606 src/Simplify.cpp replacement = substitute(new_name, Mul::make(new_var, mul->b), replacement); make 4609 src/Simplify.cpp replacement = substitute(new_name, Div::make(new_var, div->b), replacement); make 4612 src/Simplify.cpp replacement = substitute(new_name, Sub::make(new_var, sub->b), replacement); make 4615 src/Simplify.cpp replacement = substitute(new_name, Mod::make(new_var, mod->b), replacement); make 4618 src/Simplify.cpp replacement = substitute(new_name, Min::make(new_var, min->b), replacement); make 4621 src/Simplify.cpp replacement = substitute(new_name, Max::make(new_var, max->b), replacement); make 4625 src/Simplify.cpp new_var = Variable::make(new_value.type(), new_name); make 4626 src/Simplify.cpp replacement = substitute(new_name, Ramp::make(new_var, ramp->stride, ramp->lanes), replacement); make 4629 src/Simplify.cpp new_var = Variable::make(new_value.type(), new_name); make 4630 src/Simplify.cpp replacement = substitute(new_name, Broadcast::make(new_var, broadcast->lanes), replacement); make 4637 src/Simplify.cpp new_var = Variable::make(new_value.type(), new_name); make 4638 src/Simplify.cpp replacement = substitute(new_name, Cast::make(cast->type, new_var), replacement); make 4644 src/Simplify.cpp new_var = Variable::make(new_value.type(), new_name); make 4645 src/Simplify.cpp replacement = substitute(new_name, Shuffle::make({new_var}, slice_indices), replacement); make 4648 src/Simplify.cpp new_var = Variable::make(var_a ? shuffle->vectors[1].type() : shuffle->vectors[0].type(), new_name); make 4723 src/Simplify.cpp result = T::make(new_name, new_value, result); make 4728 src/Simplify.cpp result = T::make(op->name, value, result); make 4779 src/Simplify.cpp stmt = Evaluate::make(0); make 4810 src/Simplify.cpp stmt = For::make(op->name, new_min, new_extent, op->for_type, op->device_api, new_body); make 4831 src/Simplify.cpp stmt = Evaluate::make(0); make 4833 src/Simplify.cpp stmt = IfThenElse::make(scalar_pred->value, make 4834 src/Simplify.cpp Store::make(op->name, value, index, op->param, const_true(value.type().lanes()))); make 4837 src/Simplify.cpp stmt = Evaluate::make(0); make 4841 src/Simplify.cpp stmt = Store::make(op->name, value, index, op->param, predicate); make 4864 src/Simplify.cpp stmt = Allocate::make(op->name, op->type, new_extents, make 4867 src/Simplify.cpp stmt = IfThenElse::make(body_if->condition, stmt, body_if->else_case); make 4874 src/Simplify.cpp stmt = Allocate::make(op->name, op->type, new_extents, make 4895 src/Simplify.cpp stmt = Evaluate::make(value); make 4897 src/Simplify.cpp stmt = LetStmt::make(lets[i-1].first, lets[i-1].second, stmt); make 4906 src/Simplify.cpp stmt = Evaluate::make(0); make 4910 src/Simplify.cpp stmt = ProducerConsumer::make(op->name, op->is_producer, body); make 4926 src/Simplify.cpp stmt = Evaluate::make(0); make 4937 src/Simplify.cpp Stmt new_block = mutate(Block::make(let_first->body, let_rest->body)); make 4942 src/Simplify.cpp Expr new_var = Variable::make(let_first->value.type(), var_name); make 4946 src/Simplify.cpp stmt = LetStmt::make(var_name, let_first->value, new_block); make 4952 src/Simplify.cpp Stmt then_case = mutate(Block::make(if_first->then_case, if_rest->then_case)); make 4955 src/Simplify.cpp else_case = mutate(Block::make(if_first->else_case, if_rest->else_case)); make 4962 src/Simplify.cpp stmt = IfThenElse::make(if_first->condition, then_case, else_case); make 4973 src/Simplify.cpp Stmt then_case = mutate(Block::make(if_first->then_case, if_rest)); make 4975 src/Simplify.cpp stmt = IfThenElse::make(if_first->condition, then_case, else_case); make 4980 src/Simplify.cpp stmt = Block::make(first, rest); make 5067 src/Simplify.cpp return Ramp::make(base, stride, w); make 5071 src/Simplify.cpp return Broadcast::make(base, w); make 5587 src/Simplify.cpp Expr v1 = Variable::make(Int(16).with_lanes(64), "x"); make 5588 src/Simplify.cpp Expr v2 = Variable::make(Int(16).with_lanes(64), "y"); make 5670 src/Simplify.cpp Expr xv = Variable::make(Int(16).with_lanes(64), "x"); make 5671 src/Simplify.cpp Expr yv = Variable::make(Int(16).with_lanes(64), "y"); make 5672 src/Simplify.cpp Expr zv = Variable::make(Int(16).with_lanes(64), "z"); make 5699 src/Simplify.cpp Expr b1 = Variable::make(Bool(), "b1"); make 5700 src/Simplify.cpp Expr b2 = Variable::make(Bool(), "b2"); make 5817 src/Simplify.cpp Expr i = Variable::make(Int(32), "i"); make 5890 src/Simplify.cpp check(IfThenElse::make(x == 4 && y == 5, make 5891 src/Simplify.cpp Evaluate::make(z + x + y), make 5892 src/Simplify.cpp Evaluate::make(z + x - y)), make 5893 src/Simplify.cpp IfThenElse::make(x == 4 && y == 5, make 5894 src/Simplify.cpp Evaluate::make(z + 9), make 5895 src/Simplify.cpp Evaluate::make(z + x - y))); make 5898 src/Simplify.cpp check(IfThenElse::make(b1 || b2, make 5899 src/Simplify.cpp Evaluate::make(select(b1, x+3, y+4) + select(b2, x+5, y+7)), make 5900 src/Simplify.cpp Evaluate::make(select(b1, x+3, y+8) - select(b2, x+5, y+7))), make 5901 src/Simplify.cpp IfThenElse::make(b1 || b2, make 5902 src/Simplify.cpp Evaluate::make(select(b1, x+3, y+4) + select(b2, x+5, y+7)), make 5903 src/Simplify.cpp Evaluate::make(1))); make 5906 src/Simplify.cpp check(IfThenElse::make(b1, make 5907 src/Simplify.cpp Evaluate::make(select(b1, x, y)), make 5908 src/Simplify.cpp Evaluate::make(select(b1, z, w))), make 5909 src/Simplify.cpp IfThenElse::make(b1, make 5910 src/Simplify.cpp Evaluate::make(x), make 5911 src/Simplify.cpp Evaluate::make(w))); make 5913 src/Simplify.cpp check(IfThenElse::make(x < y, make 5914 src/Simplify.cpp IfThenElse::make(x < y, Evaluate::make(y), Evaluate::make(x)), make 5915 src/Simplify.cpp Evaluate::make(x)), make 5916 src/Simplify.cpp IfThenElse::make(x < y, make 5917 src/Simplify.cpp Evaluate::make(y), make 5918 src/Simplify.cpp Evaluate::make(x))); make 5920 src/Simplify.cpp check(Block::make(IfThenElse::make(x < y, Evaluate::make(x+1), Evaluate::make(x+2)), make 5921 src/Simplify.cpp IfThenElse::make(x < y, Evaluate::make(x+3), Evaluate::make(x+4))), make 5922 src/Simplify.cpp IfThenElse::make(x < y, make 5923 src/Simplify.cpp Block::make(Evaluate::make(x+1), Evaluate::make(x+3)), make 5924 src/Simplify.cpp Block::make(Evaluate::make(x+2), Evaluate::make(x+4)))); make 5926 src/Simplify.cpp check(Block::make(IfThenElse::make(x < y, Evaluate::make(x+1)), make 5927 src/Simplify.cpp IfThenElse::make(x < y, Evaluate::make(x+2))), make 5928 src/Simplify.cpp IfThenElse::make(x < y, Block::make(Evaluate::make(x+1), Evaluate::make(x+2)))); make 5930 src/Simplify.cpp check(Block::make(IfThenElse::make(x < y, Evaluate::make(x+1), Evaluate::make(x+2)), make 5931 src/Simplify.cpp IfThenElse::make(x < y, Evaluate::make(x+3))), make 5932 src/Simplify.cpp IfThenElse::make(x < y, make 5933 src/Simplify.cpp Block::make(Evaluate::make(x+1), Evaluate::make(x+3)), make 5934 src/Simplify.cpp Evaluate::make(x+2))); make 5936 src/Simplify.cpp check(Block::make(IfThenElse::make(x < y, Evaluate::make(x+1)), make 5937 src/Simplify.cpp IfThenElse::make(x < y, Evaluate::make(x+2), Evaluate::make(x+3))), make 5938 src/Simplify.cpp IfThenElse::make(x < y, make 5939 src/Simplify.cpp Block::make(Evaluate::make(x+1), Evaluate::make(x+2)), make 5940 src/Simplify.cpp Evaluate::make(x+3))); make 5945 src/Simplify.cpp check(IfThenElse::make(foo == 17, make 5946 src/Simplify.cpp Evaluate::make(x+foo+1), make 5947 src/Simplify.cpp Evaluate::make(x+foo+2)), make 5948 src/Simplify.cpp IfThenElse::make(foo_simple == 17, make 5949 src/Simplify.cpp Evaluate::make(x+18), make 5950 src/Simplify.cpp Evaluate::make(x+foo_simple+2))); make 5952 src/Simplify.cpp check(IfThenElse::make(foo != 17, make 5953 src/Simplify.cpp Evaluate::make(x+foo+1), make 5954 src/Simplify.cpp Evaluate::make(x+foo+2)), make 5955 src/Simplify.cpp IfThenElse::make(foo_simple != 17, make 5956 src/Simplify.cpp Evaluate::make(x+foo_simple+1), make 5957 src/Simplify.cpp Evaluate::make(x+19))); make 5962 src/Simplify.cpp Stmt then_clause = AssertStmt::make(b2, Expr(22)); make 5963 src/Simplify.cpp Stmt else_clause = AssertStmt::make(b2, Expr(33)); make 5964 src/Simplify.cpp check(IfThenElse::make(b1 == b2, then_clause, else_clause), make 5965 src/Simplify.cpp IfThenElse::make(b1 == b2, then_clause, else_clause)); make 6010 src/Simplify.cpp b[i] = Variable::make(Bool(), unique_name('b')); make 6263 src/Simplify.cpp UIntImm::make(UInt(64), 0xffffffffULL)); make 6265 src/Simplify.cpp v = Variable::make(Int(32, 4), "v"); make 6267 src/Simplify.cpp check(Let::make("x", 3, x+4), 7); make 6270 src/Simplify.cpp check(Let::make("v", ramp(x*2+7, 3, 4), v + Expr(broadcast(2, 4))), make 6274 src/Simplify.cpp check(Let::make("v", broadcast(x, 4), v + Expr(broadcast(2, 4))), make 6278 src/Simplify.cpp check(Let::make("x", 3*y*y*y, 4), 4); make 6279 src/Simplify.cpp check(Let::make("x", 0, 0), 0); make 6282 src/Simplify.cpp check(Evaluate::make(Let::make("x", Call::make(Int(32), "dummy", {3, x, 4}, Call::Extern), Let::make("y", 10, x + y + 2))), make 6283 src/Simplify.cpp LetStmt::make("x", Call::make(Int(32), "dummy", {3, x, 4}, Call::Extern), Evaluate::make(x + 12))); make 6290 src/Simplify.cpp check(Call::make(type_of<const char *>(), Call::stringify, {3, string(" "), 4}, Call::Intrinsic), make 6293 src/Simplify.cpp check(Call::make(type_of<const char *>(), Call::stringify, {3, x, 4, string(", "), 3.4f}, Call::Intrinsic), make 6294 src/Simplify.cpp Call::make(type_of<const char *>(), Call::stringify, {string("3"), x, string("4, 3.400000")}, Call::Intrinsic)); make 6298 src/Simplify.cpp Expr base = Variable::make(Handle(), "buf"); make 6299 src/Simplify.cpp check(Call::make(Int(32), Call::prefetch, {base, x, 4, 1, 64, 4, min(x + y, 128), 256}, Call::Intrinsic), make 6300 src/Simplify.cpp Call::make(Int(32), Call::prefetch, {base, x, min(x + y, 128) * 256, 1}, Call::Intrinsic)); make 6381 src/Simplify.cpp Expr load1 = Load::make(Float(32, 4), "buf", ramp(x, 2, 4), Buffer<>(), Parameter(), const_true(4)); make 6382 src/Simplify.cpp Expr load2 = Load::make(Float(32, 4), "buf", ramp(x+1, 2, 4), Buffer<>(), Parameter(), const_true(4)); make 6383 src/Simplify.cpp Expr load12 = Load::make(Float(32, 8), "buf", ramp(x, 1, 8), Buffer<>(), Parameter(), const_true(8)); make 6391 src/Simplify.cpp Expr load3 = Load::make(Float(32, 4), "buf2", ramp(x+1, 2, 4), Buffer<>(), Parameter(), const_true(4)); make 6401 src/Simplify.cpp loads.push_back(Load::make(Float(32), "buf", x+i, Buffer<>(), Parameter(), const_true())); make 6404 src/Simplify.cpp check(concat_vectors(loads), Load::make(Float(32, lanes), "buf", ramp(x, 1, lanes), Buffer<>(), Parameter(), const_true(lanes))); make 6419 src/Simplify.cpp Expr e = Broadcast::make(-16, 2) < (ramp(Cast::make(UInt(16), 7), Cast::make(UInt(16), 11), 2) - Broadcast::make(1, 2)); make 6420 src/Simplify.cpp Expr expected = Broadcast::make(-16, 2) < (ramp(make_const(UInt(16), 7), make_const(UInt(16), 11), 2) - Broadcast::make(1, 2)); make 6427 src/Simplify.cpp Expr value = Load::make(index.type(), "f", index, Buffer<>(), Parameter(), const_true(index.type().lanes())); make 6428 src/Simplify.cpp Stmt stmt = Store::make("f", value, index, Parameter(), pred); make 6429 src/Simplify.cpp check(stmt, Evaluate::make(0)); make 6458 src/Simplify.cpp Expr x = Variable::make(UInt(32), "x"); make 6459 src/Simplify.cpp Expr y = Variable::make(UInt(32), "y"); make 80 src/SkipStages.cpp predicate = Let::make(op->name, op->min, predicate); make 99 src/SkipStages.cpp predicate = Let::make(name, value, predicate); make 275 src/SkipStages.cpp expr = Call::make(op->type, Call::if_then_else, make 282 src/SkipStages.cpp expr = Call::make(op->type, Call::if_then_else, make 298 src/SkipStages.cpp Stmt body = IfThenElse::make(compute_predicate, op->body); make 299 src/SkipStages.cpp stmt = ProducerConsumer::make(op->name, op->is_producer, body); make 382 src/SkipStages.cpp stmt = Realize::make(op->name, op->types, op->bounds, make 210 src/SlidingWindow.cpp Expr loop_var_expr = Variable::make(Int(32), loop_var); make 252 src/SlidingWindow.cpp replacements[n + ".min"] = Variable::make(Int(32), prefix + dim + ".min"); make 253 src/SlidingWindow.cpp replacements[n + ".max"] = Variable::make(Int(32), prefix + dim + ".max"); make 266 src/SlidingWindow.cpp Expr var = Variable::make(Int(32), n); make 267 src/SlidingWindow.cpp stmt = LetStmt::make(n, min(var, b[dim_idx].min), stmt); make 270 src/SlidingWindow.cpp Expr var = Variable::make(Int(32), n); make 271 src/SlidingWindow.cpp stmt = LetStmt::make(n, max(var, b[dim_idx].max), stmt); make 284 src/SlidingWindow.cpp Stmt s = LetStmt::make(op->name, min, op->body); make 289 src/SlidingWindow.cpp stmt = For::make(op->name, op->min, op->extent, op->for_type, op->device_api, l->body); make 317 src/SlidingWindow.cpp stmt = LetStmt::make(op->name, value, new_body); make 348 src/SlidingWindow.cpp stmt = For::make(op->name, op->min, op->extent, op->for_type, op->device_api, new_body); make 392 src/SlidingWindow.cpp stmt = Realize::make(op->name, op->types, op->bounds, op->condition, new_body); make 395 src/Solve.cpp expr = mutate(T::make(t_a->a, T::make(t_a->b, b))); make 403 src/Solve.cpp expr = mutate(T::make(T::make(t_a->a, b), t_a->b)); make 406 src/Solve.cpp expr = mutate(T::make(T::make(a, t_b->a), t_b->b)); make 409 src/Solve.cpp expr = mutate(add_a->a + T::make(add_a->b, add_b->b)); make 412 src/Solve.cpp expr = mutate(T::make(add_a->a, add_b->a)) + add_a->b; make 415 src/Solve.cpp expr = mutate(b + T::make(add_a->b, make_zero(op->type))); make 418 src/Solve.cpp expr = mutate(a + T::make(add_b->b, make_zero(op->type))); make 421 src/Solve.cpp expr = mutate(sub_a->a - T::make(sub_a->b, sub_b->b)); make 424 src/Solve.cpp expr = mutate(T::make(sub_a->a, sub_b->a)) - sub_a->b; make 427 src/Solve.cpp expr = mutate(b - T::make(sub_a->b, make_zero(op->type))); make 430 src/Solve.cpp expr = mutate(a - T::make(sub_b->b, make_zero(op->type))); make 434 src/Solve.cpp expr = mutate(T::make(mul_a->a, mul_b->a)) * mul_a->b; make 438 src/Solve.cpp expr = mutate(Max::make(mul_a->a, mul_b->a)) * mul_a->b; make 441 src/Solve.cpp expr = mutate(Min::make(mul_a->a, mul_b->a)) * mul_a->b; make 444 src/Solve.cpp fail(T::make(a, b)); make 449 src/Solve.cpp expr = simplify(T::make(a, b)); make 457 src/Solve.cpp expr = T::make(a, b); make 502 src/Solve.cpp expr = mutate(T::make(t_a->a, T::make(t_a->b, b))); make 510 src/Solve.cpp expr = mutate(T::make(T::make(t_a->a, b), t_a->b)); make 513 src/Solve.cpp expr = mutate(T::make(T::make(a, t_b->a), t_b->b)); make 515 src/Solve.cpp fail(T::make(a, b)); make 520 src/Solve.cpp expr = simplify(T::make(a, b)); make 528 src/Solve.cpp expr = T::make(a, b); make 560 src/Solve.cpp expr = mutate(Opp::make(b, a)); make 582 src/Solve.cpp expr = mutate(Cmp::make(add_a->a, (b - add_a->b))); make 585 src/Solve.cpp expr = mutate(Cmp::make(sub_a->a, (b + sub_a->b))); make 590 src/Solve.cpp expr = mutate(Cmp::make(mul_a->a, (b / mul_a->b))); make 592 src/Solve.cpp expr = mutate(Opp::make(mul_a->a, (b / mul_a->b))); make 595 src/Solve.cpp expr = mutate(Opp::make(mul_a->a, make_zero(b.type()) - b)); make 600 src/Solve.cpp expr = mutate(Opp::make(mul_a->a * negate(mul_a->b), negate(b))); make 606 src/Solve.cpp Expr div = Div::make(b, mul_a->b); make 607 src/Solve.cpp Expr rem = Mod::make(b, mul_a->b); make 629 src/Solve.cpp expr = mutate(Cmp::make(div_a->a, b * div_a->b)); make 631 src/Solve.cpp expr = mutate(Opp::make(div_a->a, b * div_a->b)); make 641 src/Solve.cpp expr = mutate(Cmp::make(negate(div_a->a / negate(div_a->b)), b)); make 662 src/Solve.cpp expr = mutate(Cmp::make(a - b, make_zero(a.type()))); make 669 src/Solve.cpp expr = Cmp::make(a, b); make 854 src/Solve.cpp result.min = Let::make(op->name, op->value, result.min); make 857 src/Solve.cpp result.max = Let::make(op->name, op->value, result.max); make 941 src/Solve.cpp Expr b_var = Variable::make(b.type(), b_name); make 942 src/Solve.cpp Expr c_var = Variable::make(c.type(), c_name); make 945 src/Solve.cpp result.min = Let::make(b_name, b, result.min); make 946 src/Solve.cpp result.min = Let::make(c_name, c, result.min); make 949 src/Solve.cpp result.max = Let::make(b_name, b, result.max); make 950 src/Solve.cpp result.max = Let::make(c_name, c, result.max); make 955 src/Solve.cpp Expr b_var = Variable::make(b.type(), b_name); make 956 src/Solve.cpp Expr c_var = Variable::make(c.type(), c_name); make 959 src/Solve.cpp result.min = Let::make(b_name, b, result.min); make 960 src/Solve.cpp result.min = Let::make(c_name, c, result.min); make 963 src/Solve.cpp result.max = Let::make(b_name, b, result.max); make 964 src/Solve.cpp result.max = Let::make(c_name, c, result.max); make 995 src/Solve.cpp Expr b_var = Variable::make(b.type(), b_name); make 996 src/Solve.cpp Expr c_var = Variable::make(c.type(), c_name); make 999 src/Solve.cpp result.min = Let::make(b_name, b, result.min); make 1000 src/Solve.cpp result.min = Let::make(c_name, c, result.min); make 1003 src/Solve.cpp result.max = Let::make(b_name, b, result.max); make 1004 src/Solve.cpp result.max = Let::make(c_name, c, result.max); make 1009 src/Solve.cpp Expr b_var = Variable::make(b.type(), b_name); make 1010 src/Solve.cpp Expr c_var = Variable::make(c.type(), c_name); make 1013 src/Solve.cpp result.min = Let::make(b_name, b, result.min); make 1014 src/Solve.cpp result.min = Let::make(c_name, c, result.min); make 1017 src/Solve.cpp result.max = Let::make(b_name, b, result.max); make 1018 src/Solve.cpp result.max = Let::make(c_name, c, result.max); make 1139 src/Solve.cpp expr = Cmp::make(a, b); make 1254 src/Solve.cpp min_var = Variable::make(value_bounds.min.type(), min_name); make 1261 src/Solve.cpp max_var = Variable::make(value_bounds.max.type(), max_name); make 1269 src/Solve.cpp expr = Let::make(op->name, op->value, expr); make 1272 src/Solve.cpp expr = Let::make(min_name, value_bounds.min, expr); make 1275 src/Solve.cpp expr = Let::make(max_name, value_bounds.max, expr); make 1284 src/Solve.cpp expr = Let::make(op->name, op->value, body); make 1408 src/Solve.cpp Expr x = Variable::make(Int(32), "x"); make 1409 src/Solve.cpp Expr y = Variable::make(Int(32), "y"); make 1410 src/Solve.cpp Expr z = Variable::make(Int(32), "z"); make 1421 src/Solve.cpp check_solve(Let::make("z", 3 + 5*x, y + z < 8), make 1425 src/Solve.cpp check_solve(Let::make("z", 3 + 5*x, y + (z + z) < 8), make 1490 src/Solve.cpp Expr c = Variable::make(Bool(), "c"); make 1491 src/Solve.cpp check_outer_interval(Let::make("y", 0, x > y && x < 100), 1, 99); make 1492 src/Solve.cpp check_outer_interval(Let::make("c", x > 0, c && x < 100), 1, 99); make 1540 src/Solve.cpp Expr a16 = Load::make(Int(16), "a", {x}, Buffer<>(), Parameter(), const_true()); make 1541 src/Solve.cpp Expr b16 = Load::make(Int(16), "b", {x}, Buffer<>(), Parameter(), const_true()); make 1552 src/Solve.cpp Expr t = Variable::make(Int(32), "t"); make 1559 src/Solve.cpp Expr t = Variable::make(Int(32), "t"); make 1561 src/Solve.cpp t = min(t, Variable::make(Int(32), unique_name('v'))); make 1562 src/Solve.cpp t = max(t, Variable::make(Int(32), unique_name('v'))); make 1576 src/Solve.cpp Expr x = Variable::make(UInt(32), "x"); make 1577 src/Solve.cpp Expr y = Variable::make(UInt(32), "y"); make 1578 src/Solve.cpp Expr z = Variable::make(UInt(32), "z"); make 1584 src/Solve.cpp Expr expr = Add::make(z, Sub::make(x, y)); make 65 src/SplitTuples.cpp body = Realize::make(op->name + "." + std::to_string(i), {op->types[i]}, op->bounds, op->condition, body); make 95 src/SplitTuples.cpp stmt = Prefetch::make(op->name + "." + std::to_string(*it), {op->types[(*it)]}, op->bounds); make 98 src/SplitTuples.cpp stmt = Block::make(stmt, Prefetch::make(op->name + "." + std::to_string(*it), {op->types[(*it)]}, op->bounds)); make 122 src/SplitTuples.cpp expr = Call::make(op->type, name, args, op->call_type, f.get_contents()); make 176 src/SplitTuples.cpp val = Variable::make(val.type(), var_name); make 178 src/SplitTuples.cpp provides.push_back(Provide::make(name, {val}, args)); make 181 src/SplitTuples.cpp Stmt result = Block::make(provides); make 186 src/SplitTuples.cpp result = LetStmt::make(p.first, p.second, result); make 368 src/StmtToHtml.cpp print_list({Variable::make(Int(32), op->name), op->min, op->extent}); make 58 src/StorageFlattening.cpp strides[i] = Variable::make(Int(32), stride_name, buf, param, rdom); make 59 src/StorageFlattening.cpp mins[i] = Variable::make(Int(32), min_name, buf, param, rdom); make 149 src/StorageFlattening.cpp min_var[i] = Variable::make(Int(32), min_name[i]); make 150 src/StorageFlattening.cpp extent_var[i] = Variable::make(Int(32), extent_name[i]); make 151 src/StorageFlattening.cpp stride_var[i] = Variable::make(Int(32), stride_name[i]); make 156 src/StorageFlattening.cpp builder.host = Variable::make(Handle(), op->name); make 164 src/StorageFlattening.cpp stmt = LetStmt::make(op->name + ".buffer", builder.build(), stmt); make 167 src/StorageFlattening.cpp stmt = Allocate::make(op->name, op->types[0], extents, condition, stmt); make 174 src/StorageFlattening.cpp stmt = LetStmt::make(stride_name[j], stride, stmt); make 180 src/StorageFlattening.cpp stmt = LetStmt::make(stride_name[innermost], 1, stmt); make 185 src/StorageFlattening.cpp stmt = LetStmt::make(min_name[i-1], op->bounds[i-1].min, stmt); make 186 src/StorageFlattening.cpp stmt = LetStmt::make(extent_name[i-1], extents[i-1], stmt); make 211 src/StorageFlattening.cpp stmt = Store::make(op->name, value, idx, output_buf, const_true(value.type().lanes())); make 219 src/StorageFlattening.cpp expr = Load::make(op->type, op->name, idx, op->image, op->param, make 236 src/StorageFlattening.cpp prefetch_stride[i] = Variable::make(Int(32), op->name + ".stride." + std::to_string(i), op->param); make 240 src/StorageFlattening.cpp Expr base_address = Variable::make(Handle(), op->name); make 275 src/StorageFlattening.cpp stmt = Evaluate::make(Call::make(op->types[0], Call::prefetch, args, Call::Intrinsic)); make 305 src/StorageFlattening.cpp expr = Cast::make(op->type, Load::make(t, op->name, mutate(op->index), make 315 src/StorageFlattening.cpp stmt = Store::make(op->name, Cast::make(t, mutate(op->value)), mutate(op->index), make 329 src/StorageFlattening.cpp stmt = Allocate::make(op->name, t, extents, make 69 src/StorageFolding.cpp expr = Call::make(op->type, op->name, args, op->call_type, make 81 src/StorageFolding.cpp stmt = Provide::make(op->name, op->values, args); make 155 src/StorageFolding.cpp Expr loop_var = Variable::make(Int(32), op->name); make 171 src/StorageFolding.cpp Expr error = Call::make(Int(32), "halide_error_bad_fold", make 175 src/StorageFolding.cpp body = Block::make(AssertStmt::make(condition, error), body); make 184 src/StorageFolding.cpp Expr error = Call::make(Int(32), "halide_error_fold_factor_too_small", make 187 src/StorageFolding.cpp body = Block::make(AssertStmt::make(extent <= explicit_factor, error), body); make 193 src/StorageFolding.cpp scope.push(op->name, Interval(Variable::make(Int(32), op->name + ".loop_min"), make 194 src/StorageFolding.cpp Variable::make(Int(32), op->name + ".loop_max"))); make 218 src/StorageFolding.cpp Expr next_var = Variable::make(Int(32), op->name) + 1; make 226 src/StorageFolding.cpp stmt = For::make(op->name, op->min, op->extent, op->for_type, op->device_api, body); make 250 src/StorageFolding.cpp stmt = For::make(op->name, op->min, op->extent, op->for_type, op->device_api, body); make 314 src/StorageFolding.cpp stmt = Realize::make(op->name, op->types, op->bounds, op->condition, body); make 327 src/StorageFolding.cpp stmt = Realize::make(op->name, op->types, op->bounds, op->condition, body); make 340 src/StorageFolding.cpp stmt = Realize::make(op->name, op->types, bounds, op->condition, body); make 370 src/StorageFolding.cpp stmt = LetStmt::make(op->name, value, body); make 49 src/Substitute.cpp expr = Let::make(op->name, new_value, new_body); make 63 src/Substitute.cpp stmt = LetStmt::make(op->name, new_value, new_body); make 80 src/Substitute.cpp stmt = For::make(op->name, new_min, new_extent, op->for_type, op->device_api, new_body); make 23 src/Tracing.cpp Expr values = Call::make(type_of<void *>(), Call::make_struct, make 25 src/Tracing.cpp Expr coords = Call::make(type_of<int32_t *>(), Call::make_struct, make 37 src/Tracing.cpp return Call::make(Int(32), Call::trace, args, Call::Extern); make 80 src/Tracing.cpp trace_parent = Variable::make(Int(32), op->name + ".trace_id"); make 83 src/Tracing.cpp trace_parent = Variable::make(Int(32), "pipeline.trace_id"); make 88 src/Tracing.cpp Expr value_var = Variable::make(op->type, value_var_name); make 100 src/Tracing.cpp expr = Let::make(value_var_name, op, make 101 src/Tracing.cpp Call::make(op->type, Call::return_second, make 126 src/Tracing.cpp builder.parent_id = Variable::make(Int(32), op->name + ".trace_id"); make 130 src/Tracing.cpp Expr value_var = Variable::make(t, value_var_name); make 137 src/Tracing.cpp traces[i] = Let::make(value_var_name, values[i], make 138 src/Tracing.cpp Call::make(t, Call::return_second, make 151 src/Tracing.cpp args[i] = Variable::make(args[i].type(), name); make 155 src/Tracing.cpp stmt = Provide::make(op->name, traces, args); make 157 src/Tracing.cpp stmt = LetStmt::make(p.first, p.second, stmt); make 174 src/Tracing.cpp builder.parent_id = Variable::make(Int(32), "pipeline.trace_id"); make 185 src/Tracing.cpp builder.parent_id = Variable::make(Int(32), op->name + ".trace_id"); make 188 src/Tracing.cpp new_body = Block::make(new_body, Evaluate::make(call_after)); make 189 src/Tracing.cpp new_body = LetStmt::make(op->name + ".trace_id", call_before, new_body); make 190 src/Tracing.cpp stmt = Realize::make(op->name, op->types, op->bounds, op->condition, new_body); make 194 src/Tracing.cpp new_body = LetStmt::make(op->name + ".trace_id", 0, new_body); make 195 src/Tracing.cpp stmt = Realize::make(op->name, op->types, op->bounds, op->condition, new_body); make 211 src/Tracing.cpp builder.parent_id = Variable::make(Int(32), op->name + ".trace_id"); make 216 src/Tracing.cpp Expr min = Variable::make(Int(32), f.name() + ".s0." + f_args[i] + ".min"); make 217 src/Tracing.cpp Expr max = Variable::make(Int(32), f.name() + ".s0." + f_args[i] + ".max"); make 234 src/Tracing.cpp Stmt new_body = Block::make(op->body, Evaluate::make(end_op_call)); make 236 src/Tracing.cpp stmt = LetStmt::make(f.name() + ".trace_id", begin_op_call, make 237 src/Tracing.cpp ProducerConsumer::make(op->name, op->is_producer, new_body)); make 273 src/Tracing.cpp Expr min = Variable::make(Int(32), output_buf.name() + ".min." + d); make 274 src/Tracing.cpp Expr extent = Variable::make(Int(32), output_buf.name() + ".extent." + d); make 277 src/Tracing.cpp s = Realize::make(output.name(), output.output_types(), output_region, const_true(), s); make 296 src/Tracing.cpp builder.parent_id = Variable::make(Int(32), "pipeline.trace_id"); make 299 src/Tracing.cpp s = Block::make(s, Evaluate::make(pipeline_end)); make 300 src/Tracing.cpp s = LetStmt::make("pipeline.trace_id", pipeline_start, s); make 98 src/TrimNoOps.cpp Expr equivalent_load = Load::make(op->value.type(), op->name, op->index, make 161 src/TrimNoOps.cpp condition = Let::make(op->name, op->value, condition); make 206 src/TrimNoOps.cpp test = common_subexpression_elimination(Let::make(loop.var, loop.i.min, test)); make 215 src/TrimNoOps.cpp test = common_subexpression_elimination(Let::make(loop.var, loop.i.min, test) || make 216 src/TrimNoOps.cpp Let::make(loop.var, loop.i.max, test)); make 246 src/TrimNoOps.cpp expr = Min::make(a, b); make 262 src/TrimNoOps.cpp expr = Max::make(a, b); make 307 src/TrimNoOps.cpp return LetStmtOrLet::make(op->name, value, body); make 325 src/TrimNoOps.cpp stmt = For::make(op->name, min, extent, op->for_type, op->device_api, body); make 359 src/TrimNoOps.cpp stmt = Evaluate::make(0); make 363 src/TrimNoOps.cpp stmt = For::make(op->name, op->min, op->extent, op->for_type, op->device_api, body); make 376 src/TrimNoOps.cpp stmt = For::make(op->name, op->min, op->extent, op->for_type, op->device_api, body); make 382 src/TrimNoOps.cpp stmt = Evaluate::make(0); make 393 src/TrimNoOps.cpp Expr new_min_var = Variable::make(Int(32), new_min_name); make 394 src/TrimNoOps.cpp Expr new_max_var = Variable::make(Int(32), new_max_name); make 395 src/TrimNoOps.cpp Expr old_max_var = Variable::make(Int(32), old_max_name); make 419 src/TrimNoOps.cpp stmt = For::make(op->name, new_min_var, new_extent, op->for_type, op->device_api, body); make 420 src/TrimNoOps.cpp stmt = LetStmt::make(new_max_name, new_max, stmt); make 421 src/TrimNoOps.cpp stmt = LetStmt::make(new_min_name, new_min, stmt); make 422 src/TrimNoOps.cpp stmt = LetStmt::make(old_max_name, old_max, stmt); make 29 src/Type.cpp return Internal::Broadcast::make(element_of().max(), lanes()); make 31 src/Type.cpp return Internal::IntImm::make(*this, max_int(bits())); make 33 src/Type.cpp return Internal::UIntImm::make(*this, max_uint(bits())); make 37 src/Type.cpp return Internal::FloatImm::make(*this, 65504.0); make 39 src/Type.cpp return Internal::FloatImm::make(*this, FLT_MAX); make 41 src/Type.cpp return Internal::FloatImm::make(*this, DBL_MAX); make 53 src/Type.cpp return Internal::Broadcast::make(element_of().min(), lanes()); make 55 src/Type.cpp return Internal::IntImm::make(*this, min_int(bits())); make 57 src/Type.cpp return Internal::UIntImm::make(*this, 0); make 61 src/Type.cpp return Internal::FloatImm::make(*this, -65504.0); make 63 src/Type.cpp return Internal::FloatImm::make(*this, -FLT_MAX); make 65 src/Type.cpp return Internal::FloatImm::make(*this, -DBL_MAX); make 27 src/UnifyDuplicateLets.cpp expr = Variable::make(e.type(), iter->second); make 42 src/UnifyDuplicateLets.cpp expr = Variable::make(op->type, iter->second); make 86 src/UnifyDuplicateLets.cpp value = Variable::make(value.type(), iter->second); make 104 src/UnifyDuplicateLets.cpp stmt = LetStmt::make(op->name, value, body); make 53 src/UniquifyVariableNames.cpp stmt = LetStmt::make(new_name, value, body); make 70 src/UniquifyVariableNames.cpp expr = Let::make(new_name, value, body); make 89 src/UniquifyVariableNames.cpp stmt = For::make(new_name, min, extent, op->for_type, op->device_api, body); make 96 src/UniquifyVariableNames.cpp expr = Variable::make(op->type, new_name); make 29 src/UnpackBuffers.cpp BufferInfo {Variable::make(type_of<buffer_t *>(), name + ".buffer", param), make 39 src/UnpackBuffers.cpp BufferInfo {Variable::make(type_of<buffer_t *>(), name + ".buffer", buffer), make 79 src/UnpackBuffers.cpp Expr host_val = Call::make(type_of<void *>(), Call::buffer_get_host, args, Call::Extern); make 83 src/UnpackBuffers.cpp Expr dev_val = Call::make(type_of<uint64_t>(), Call::buffer_get_device, args, Call::Extern); make 87 src/UnpackBuffers.cpp Expr dev_interface_val = Call::make(type_of<const halide_device_interface_t *>(), make 92 src/UnpackBuffers.cpp Expr type_code_val = Call::make(UInt(8), Call::buffer_get_type_code, args, Call::Extern); make 96 src/UnpackBuffers.cpp Expr type_bits_val = Call::make(UInt(8), Call::buffer_get_type_bits, args, Call::Extern); make 100 src/UnpackBuffers.cpp Expr type_lanes_val = Call::make(UInt(16), Call::buffer_get_type_lanes, args, Call::Extern); make 104 src/UnpackBuffers.cpp Expr host_dirty_val = Call::make(Bool(), Call::buffer_get_host_dirty, args, Call::Extern); make 108 src/UnpackBuffers.cpp Expr dev_dirty_val = Call::make(Bool(), Call::buffer_get_device_dirty, args, Call::Extern); make 115 src/UnpackBuffers.cpp Expr min_val = Call::make(Int(32), Call::buffer_get_min, args, Call::Extern); make 119 src/UnpackBuffers.cpp Expr extent_val = Call::make(Int(32), Call::buffer_get_extent, args, Call::Extern); make 123 src/UnpackBuffers.cpp Expr stride_val = Call::make(Int(32), Call::buffer_get_stride, args, Call::Extern); make 132 src/UnpackBuffers.cpp s = LetStmt::make(l.first, l.second, s); make 140 src/UnpackBuffers.cpp Expr error = Call::make(Int(32), "halide_error_buffer_argument_is_null", make 142 src/UnpackBuffers.cpp Stmt check = AssertStmt::make(cond, error); make 143 src/UnpackBuffers.cpp s = Block::make(check, s); make 34 src/UnrollLoops.cpp stmt = Block::make(iters); make 149 src/Var.h return Internal::Variable::make(Int(32), name()); make 16 src/VaryingAttributes.cpp return Block::make(first, rest); make 49 src/VaryingAttributes.cpp Expr intrinsic = Call::make(e.type(), Call::glsl_varying, make 87 src/VaryingAttributes.cpp expr = Call::make(op->type, op->name, new_args, op->call_type, make 102 src/VaryingAttributes.cpp mutated_value = Call::make(mutated_value.type(), Call::glsl_varying, make 108 src/VaryingAttributes.cpp expr = Let::make(op->name, mutated_value, mutated_body); make 139 src/VaryingAttributes.cpp stmt = For::make(op->name, op->min, op->extent, op->for_type, op->device_api, mutated_body); make 176 src/VaryingAttributes.cpp expr = Cast::make(op->type, mutated_value); make 199 src/VaryingAttributes.cpp expr = T::make(a, b); make 224 src/VaryingAttributes.cpp expr = Mul::make(a, b); make 252 src/VaryingAttributes.cpp expr = Div::make(a, b); make 276 src/VaryingAttributes.cpp expr = T::make(a, b); make 307 src/VaryingAttributes.cpp expr = Not::make(a); make 321 src/VaryingAttributes.cpp expr = Broadcast::make(a, op->lanes); make 359 src/VaryingAttributes.cpp expr = Select::make(mutated_condition, mutated_true_value, mutated_false_value); make 443 src/VaryingAttributes.cpp expr = Variable::make(op->type, name); make 509 src/VaryingAttributes.cpp Expr v = Variable::make(Float(32), op->name); make 514 src/VaryingAttributes.cpp expr = Cast::make(op->type, floor(v + 0.5f)); make 540 src/VaryingAttributes.cpp expr = Variable::make(scope.get(op->name).type(), op->name); make 561 src/VaryingAttributes.cpp mutated_a = Cast::make(float_type(op->b), mutated_a); make 564 src/VaryingAttributes.cpp mutated_b = Cast::make(float_type(op->a), mutated_b); make 568 src/VaryingAttributes.cpp expr = T::make(mutated_a, mutated_b); make 598 src/VaryingAttributes.cpp mutated_true_value = Cast::make(float_type(op->true_value), mutated_true_value); make 601 src/VaryingAttributes.cpp mutated_false_value = Cast::make(float_type(op->false_value), mutated_false_value); make 605 src/VaryingAttributes.cpp expr = Select::make(mutated_condition, mutated_true_value, mutated_false_value); make 616 src/VaryingAttributes.cpp mutated_base = Cast::make(float_type(op->base), mutated_base); make 619 src/VaryingAttributes.cpp mutated_stride = Cast::make(float_type(op->stride), mutated_stride); make 626 src/VaryingAttributes.cpp expr = Ramp::make(mutated_base, mutated_stride, op->lanes); make 644 src/VaryingAttributes.cpp expr = Let::make(op->name, mutated_value, mutated_body); make 661 src/VaryingAttributes.cpp stmt = LetStmt::make(op->name, mutated_value, mutated_body); make 950 src/VaryingAttributes.cpp Expr offset_expression = Variable::make(Int(32), "gpu.vertex_offset") + make 953 src/VaryingAttributes.cpp stmt = Store::make(vertex_buffer_name, op->args[1], offset_expression, make 971 src/VaryingAttributes.cpp stmt = LetStmt::make(op->name, op->value, mutated_body); make 989 src/VaryingAttributes.cpp stmt = LetStmt::make(op->name, op->value, mutated_body); make 1008 src/VaryingAttributes.cpp Expr loop_variable = Variable::make(Int(32),name); make 1027 src/VaryingAttributes.cpp Expr gpu_varying_offset = Variable::make(Int(32), "gpu.vertex_offset"); make 1030 src/VaryingAttributes.cpp Expr coord1 = cast<float>(Variable::make(Int(32),for_loops[0]->name)); make 1031 src/VaryingAttributes.cpp Expr coord0 = cast<float>(Variable::make(Int(32),for_loops[1]->name)); make 1051 src/VaryingAttributes.cpp mutated_body = make_block(Store::make(vertex_buffer_name, make 1057 src/VaryingAttributes.cpp mutated_body = make_block(Store::make(vertex_buffer_name, make 1068 src/VaryingAttributes.cpp mutated_body = LetStmt::make("gpu.vertex_offset", make 1075 src/VaryingAttributes.cpp Stmt loop_var = LetStmt::make(op->name, coord_expr, mutated_body); make 1077 src/VaryingAttributes.cpp stmt = For::make(name, 0, (int)dim.size(), ForType::Serial, DeviceAPI::None, loop_var); make 1122 src/VaryingAttributes.cpp return Internal::Call::make(v_.type(), make 1129 src/VaryingAttributes.cpp return Evaluate::make(Internal::Call::make(Int(32), make 1131 src/VaryingAttributes.cpp {Variable::make(type_, v_), 0}, make 1175 src/VaryingAttributes.cpp Expr loop0_max = Add::make(loop0->min, loop0->extent); make 1176 src/VaryingAttributes.cpp Expr loop1_max = Add::make(loop1->min, loop1->extent); make 1241 src/VaryingAttributes.cpp stmt = LetStmt::make("glsl.num_coords_dim0", dont_simplify((int)(coords[0].size())), make 1242 src/VaryingAttributes.cpp LetStmt::make("glsl.num_coords_dim1", dont_simplify((int)(coords[1].size())), make 1243 src/VaryingAttributes.cpp LetStmt::make("glsl.num_padded_attributes", dont_simplify(num_padded_attributes), make 1244 src/VaryingAttributes.cpp Allocate::make(vs.vertex_buffer_name, Float(32), {vertex_buffer_size}, const_true(), make 1245 src/VaryingAttributes.cpp Block::make(vertex_setup, make 1246 src/VaryingAttributes.cpp Block::make(loop_stmt, make 1247 src/VaryingAttributes.cpp Block::make(used_in_codegen(Int(32), "glsl.num_coords_dim0"), make 1248 src/VaryingAttributes.cpp Block::make(used_in_codegen(Int(32), "glsl.num_coords_dim1"), make 1249 src/VaryingAttributes.cpp Block::make(used_in_codegen(Int(32), "glsl.num_padded_attributes"), make 1250 src/VaryingAttributes.cpp Free::make(vs.vertex_buffer_name)))))))))); make 38 src/VectorizeLoops.cpp expr = Variable::make(op->type, var + ".lane." + std::to_string(op->indices[0])); make 118 src/VectorizeLoops.cpp return {Min::make(ia.min, b->value), Min::make(ia.max, b->value)}; make 121 src/VectorizeLoops.cpp return {Min::make(ia.min, b->value), Min::make(ia.max, b->value)}; make 126 src/VectorizeLoops.cpp return {Max::make(ia.min, b->value), Max::make(ia.max, b->value)}; make 129 src/VectorizeLoops.cpp return {Max::make(ia.min, b->value), Max::make(ia.max, b->value)}; make 144 src/VectorizeLoops.cpp return {Variable::make(var->type.element_of(), var->name + ".min_lane"), make 145 src/VectorizeLoops.cpp Variable::make(var->type.element_of(), var->name + ".max_lane")}; make 150 src/VectorizeLoops.cpp ib.min = Let::make(let->name + ".min_lane", ia.min, ib.min); make 153 src/VectorizeLoops.cpp ib.max = Let::make(let->name + ".min_lane", ia.min, ib.max); make 156 src/VectorizeLoops.cpp ib.min = Let::make(let->name + ".max_lane", ia.max, ib.min); make 159 src/VectorizeLoops.cpp ib.max = Let::make(let->name + ".max_lane", ia.max, ib.max); make 170 src/VectorizeLoops.cpp min_lane = And::make(min_lane, next_lane); make 171 src/VectorizeLoops.cpp max_lane = Or::make(max_lane, next_lane); make 173 src/VectorizeLoops.cpp min_lane = Min::make(min_lane, next_lane); make 174 src/VectorizeLoops.cpp max_lane = Max::make(max_lane, next_lane); make 201 src/VectorizeLoops.cpp expr = Load::make(op->type, op->name, mutate_index(op->name, op->index), make 206 src/VectorizeLoops.cpp stmt = Store::make(op->name, mutate(op->value), mutate_index(op->name, op->index), make 212 src/VectorizeLoops.cpp var(Variable::make(Int(32), v)), alloc(a), lanes(l) {} make 284 src/VectorizeLoops.cpp predicate = mutate(Broadcast::make(op->predicate, lanes)); make 285 src/VectorizeLoops.cpp index = mutate(Broadcast::make(op->index, lanes)); make 296 src/VectorizeLoops.cpp expr = Load::make(op->type, op->name, index, op->image, op->param, predicate); make 317 src/VectorizeLoops.cpp predicate = mutate(Broadcast::make(op->predicate, lanes)); make 318 src/VectorizeLoops.cpp value = mutate(Broadcast::make(op->value, lanes)); make 319 src/VectorizeLoops.cpp index = mutate(Broadcast::make(op->index, lanes)); make 330 src/VectorizeLoops.cpp stmt = Store::make(op->name, value, op->index, op->param, predicate); make 381 src/VectorizeLoops.cpp return Broadcast::make(e, lanes); make 396 src/VectorizeLoops.cpp expr = Cast::make(t, value); make 407 src/VectorizeLoops.cpp expr = Variable::make(scope.get(op->name).type(), widened_name); make 420 src/VectorizeLoops.cpp expr = T::make(widen(a, w), widen(b, w)); make 454 src/VectorizeLoops.cpp expr = Select::make(condition, true_value, false_value); make 467 src/VectorizeLoops.cpp expr = Load::make(op->type.with_lanes(w), op->name, index, op->image, make 504 src/VectorizeLoops.cpp new_args[i] = Call::make(call->type.element_of(), Call::make_struct, make 511 src/VectorizeLoops.cpp expr = Call::make(op->type, Call::trace, new_args, op->call_type); make 517 src/VectorizeLoops.cpp expr = Call::make(op->type.with_lanes(max_lanes), op->name, new_args, make 546 src/VectorizeLoops.cpp expr = Let::make(vectorized_name, mutated_value, mutated_body); make 548 src/VectorizeLoops.cpp expr = Let::make(op->name, mutated_value, mutated_body); make 586 src/VectorizeLoops.cpp LetStmt::make(lane_name, extract_lane(mutated_value, i), mutated_body); make 599 src/VectorizeLoops.cpp LetStmt::make(mutated_name + ".min_lane", i.min, mutated_body); make 604 src/VectorizeLoops.cpp LetStmt::make(mutated_name + ".max_lane", i.max, mutated_body); make 613 src/VectorizeLoops.cpp stmt = LetStmt::make(mutated_name, mutated_value, mutated_body); make 650 src/VectorizeLoops.cpp stmt = Provide::make(op->name, new_values, new_args); make 663 src/VectorizeLoops.cpp stmt = Store::make(op->name, widen(value, lanes), widen(index, lanes), make 700 src/VectorizeLoops.cpp predicated_stmt = Block::make(predicated_stmt, p.mutate(else_case)); make 720 src/VectorizeLoops.cpp all_true = Call::make(Bool(), c->name, make 728 src/VectorizeLoops.cpp IfThenElse::make(op->condition.as<Call>()->args[0], make 731 src/VectorizeLoops.cpp IfThenElse::make(all_true, make 737 src/VectorizeLoops.cpp IfThenElse::make(all_true, make 760 src/VectorizeLoops.cpp stmt = IfThenElse::make(cond, then_case, else_case); make 781 src/VectorizeLoops.cpp Expr var = Variable::make(Int(32), op->name); make 783 src/VectorizeLoops.cpp Stmt transformed = For::make(op->name, 0, op->extent, for_type, op->device_api, body); make 794 src/VectorizeLoops.cpp Expr var = Variable::make(Int(32), op->name); make 795 src/VectorizeLoops.cpp body = IfThenElse::make(likely(var < op->min + op->extent), body); make 806 src/VectorizeLoops.cpp stmt = For::make(op->name, min, extent, for_type, op->device_api, body); make 845 src/VectorizeLoops.cpp scope.push(v, Ramp::make(0, 1, lanes)); make 851 src/VectorizeLoops.cpp body = substitute(v + widening_suffix, Ramp::make(0, 1, lanes), body); make 854 src/VectorizeLoops.cpp body = substitute(v, Variable::make(Int(32), var), body); make 856 src/VectorizeLoops.cpp stmt = Allocate::make(op->name, op->type, new_extents, op->condition, body, new_expr, op->free_function); make 866 src/VectorizeLoops.cpp s = LetStmt::make(l.first, l.second, s); make 871 src/VectorizeLoops.cpp s = For::make(var, r->base, r->lanes, ForType::Serial, DeviceAPI::None, s); make 889 src/VectorizeLoops.cpp e = substitute(iter.name(), Variable::make(lane.type(), name), e); make 897 src/VectorizeLoops.cpp result = Broadcast::make(e, lanes); make 899 src/VectorizeLoops.cpp Expr cond = (replacement == Broadcast::make(i, lanes)); make 900 src/VectorizeLoops.cpp result = Select::make(cond, Broadcast::make(e, lanes), result); make 939 src/VectorizeLoops.cpp Expr for_var = Variable::make(Int(32), for_loop->name); make 940 src/VectorizeLoops.cpp Expr replacement = Ramp::make(for_loop->min, 1, extent->value); make 24 src/WrapExternStages.cpp Expr result_var = Variable::make(Int(32), result_var_name); make 25 src/WrapExternStages.cpp Stmt s = AssertStmt::make(result_var == 0, result_var); make 26 src/WrapExternStages.cpp s = LetStmt::make(result_var_name, call, s); make 73 src/WrapExternStages.cpp Expr new_buffer_var = Variable::make(a.type, a.name + ".buffer"); make 77 src/WrapExternStages.cpp Expr old_buffer_var = Variable::make(type_of<struct buffer_t *>(), old_buffer_name); make 78 src/WrapExternStages.cpp Expr old_buffer = Call::make(type_of<struct buffer_t *>(), Call::alloca, make 84 src/WrapExternStages.cpp Expr downgrade_call = Call::make(Int(32), "halide_downgrade_buffer_t", make 92 src/WrapExternStages.cpp Expr upgrade_call = Call::make(Int(32), "halide_upgrade_buffer_t", make 98 src/WrapExternStages.cpp call_args.push_back(Variable::make(a.type, a.name)); make 102 src/WrapExternStages.cpp Expr inner_call = Call::make(op->type, op->name, call_args, op->call_type); make 104 src/WrapExternStages.cpp body = Block::make({Block::make(downgrades), body, Block::make(upgrades)}); make 108 src/WrapExternStages.cpp body = LetStmt::make(p.first, p.second, body); make 132 src/WrapExternStages.cpp expr = Call::make(op->type, make_wrapper(op), new_args, Call::Extern, op->func); make 172 src/WrapExternStages.cpp call_args.push_back(Variable::make(arg.type, arg.name)); make 178 src/WrapExternStages.cpp Expr new_buffer_var = Variable::make(type_of<struct halide_buffer_t *>(), new_buffer_name); make 180 src/WrapExternStages.cpp Expr old_buffer_var = Variable::make(type_of<struct buffer_t *>(), arg.name); make 193 src/WrapExternStages.cpp Expr downgrade_call = Call::make(Int(32), "halide_downgrade_buffer_t", make 199 src/WrapExternStages.cpp Expr downgrade_device_call = Call::make(Int(32), "halide_downgrade_buffer_t_device_fields", make 204 src/WrapExternStages.cpp Expr bounds_query = Call::make(Bool(), Call::buffer_is_bounds_query, make 206 src/WrapExternStages.cpp downgrade = IfThenElse::make(bounds_query, downgrade, downgrade_device); make 212 src/WrapExternStages.cpp Expr upgrade_call = Call::make(Int(32), "halide_upgrade_buffer_t", make 227 src/WrapExternStages.cpp Expr inner_call = Call::make(Int(32), fn.name, call_args, call_type); make 229 src/WrapExternStages.cpp body = Block::make({Block::make(upgrades), body, Block::make(downgrades)}); make 233 src/WrapExternStages.cpp body = LetStmt::make(p.first, p.second, body); make 38 test/correctness/buffer_t.cpp Internal::Call::make(Int(32), Internal::Call::size_of_halide_buffer_t, {}, Internal::Call::Intrinsic)); make 115 test/correctness/exception.cpp Internal::Add::make(a, b); make 26 test/correctness/fuzz_simplify.cpp return Variable::make(Int(0), fuzz_var(fuzz_count)); make 60 test/correctness/fuzz_simplify.cpp return Ramp::make(e1, e2, T.lanes()); make 63 test/correctness/fuzz_simplify.cpp return Broadcast::make(e1, T.lanes()); make 73 test/correctness/fuzz_simplify.cpp EQ::make, make 74 test/correctness/fuzz_simplify.cpp NE::make, make 75 test/correctness/fuzz_simplify.cpp LT::make, make 76 test/correctness/fuzz_simplify.cpp LE::make, make 77 test/correctness/fuzz_simplify.cpp GT::make, make 78 test/correctness/fuzz_simplify.cpp GE::make, make 95 test/correctness/fuzz_simplify.cpp Add::make, make 96 test/correctness/fuzz_simplify.cpp Sub::make, make 97 test/correctness/fuzz_simplify.cpp Mul::make, make 98 test/correctness/fuzz_simplify.cpp Min::make, make 99 test/correctness/fuzz_simplify.cpp Max::make, make 100 test/correctness/fuzz_simplify.cpp Div::make, make 101 test/correctness/fuzz_simplify.cpp Mod::make, make 105 test/correctness/fuzz_simplify.cpp And::make, make 106 test/correctness/fuzz_simplify.cpp Or::make, make 128 test/correctness/fuzz_simplify.cpp return Select::make(c, e1, e2); make 133 test/correctness/fuzz_simplify.cpp return Broadcast::make(e1, T.lanes()); make 140 test/correctness/fuzz_simplify.cpp return Ramp::make(e1, e2, T.lanes()); make 147 test/correctness/fuzz_simplify.cpp return Not::make(e1); make 166 test/correctness/fuzz_simplify.cpp return Cast::make(T, e1); make 236 test/correctness/fuzz_simplify.cpp Expr ramp(Expr b, Expr s, int w) { return Ramp::make(b, s, w); } make 237 test/correctness/fuzz_simplify.cpp Expr x1(Expr x) { return Broadcast::make(x, 2); } make 238 test/correctness/fuzz_simplify.cpp Expr x2(Expr x) { return Broadcast::make(x, 2); } make 239 test/correctness/fuzz_simplify.cpp Expr x4(Expr x) { return Broadcast::make(x, 2); } make 240 test/correctness/fuzz_simplify.cpp Expr uint1(Expr x) { return Cast::make(UInt(1), x); } make 241 test/correctness/fuzz_simplify.cpp Expr uint8(Expr x) { return Cast::make(UInt(8), x); } make 242 test/correctness/fuzz_simplify.cpp Expr uint16(Expr x) { return Cast::make(UInt(16), x); } make 243 test/correctness/fuzz_simplify.cpp Expr uint32(Expr x) { return Cast::make(UInt(32), x); } make 244 test/correctness/fuzz_simplify.cpp Expr int8(Expr x) { return Cast::make(Int(8), x); } make 245 test/correctness/fuzz_simplify.cpp Expr int16(Expr x) { return Cast::make(Int(16), x); } make 246 test/correctness/fuzz_simplify.cpp Expr int32(Expr x) { return Cast::make(Int(32), x); } make 247 test/correctness/fuzz_simplify.cpp Expr uint1x2(Expr x) { return Cast::make(UInt(1).with_lanes(2), x); } make 248 test/correctness/fuzz_simplify.cpp Expr uint8x2(Expr x) { return Cast::make(UInt(8).with_lanes(2), x); } make 249 test/correctness/fuzz_simplify.cpp Expr uint16x2(Expr x) { return Cast::make(UInt(16).with_lanes(2), x); } make 250 test/correctness/fuzz_simplify.cpp Expr uint32x2(Expr x) { return Cast::make(UInt(32).with_lanes(2), x); } make 251 test/correctness/fuzz_simplify.cpp Expr int8x2(Expr x) { return Cast::make(Int(8).with_lanes(2), x); } make 252 test/correctness/fuzz_simplify.cpp Expr int16x2(Expr x) { return Cast::make(Int(16).with_lanes(2), x); } make 253 test/correctness/fuzz_simplify.cpp Expr int32x2(Expr x) { return Cast::make(Int(32).with_lanes(2), x); } make 255 test/correctness/fuzz_simplify.cpp Expr a(Variable::make(Int(0), fuzz_var(0))); make 256 test/correctness/fuzz_simplify.cpp Expr b(Variable::make(Int(0), fuzz_var(1))); make 257 test/correctness/fuzz_simplify.cpp Expr c(Variable::make(Int(0), fuzz_var(2))); make 258 test/correctness/fuzz_simplify.cpp Expr d(Variable::make(Int(0), fuzz_var(3))); make 259 test/correctness/fuzz_simplify.cpp Expr e(Variable::make(Int(0), fuzz_var(4))); make 48 test/correctness/make_struct.cpp Expr s = Call::make(Handle(), Call::make_struct, {a, b, c, d}, Call::Intrinsic); make 5 test/generator/cxx_mangling_generator.cpp return Halide::Internal::Call::make(Halide::type_of<int>(), make 11 test/generator/cxx_mangling_generator.cpp return Halide::Internal::Call::make(Halide::type_of<int>(),