Lines Matching refs:arguments
33 static bool has_compile_time_constant_arguments(const ExpressionArray& arguments) {
34 for (const std::unique_ptr<Expression>& arg : arguments) {
83 // Takes up to two vector or scalar arguments and coalesces them in sequence:
91 // If an argument is null, zero is passed to the coalesce function. If the arguments are a mix
134 static std::unique_ptr<Expression> coalesce_vector(const IntrinsicArguments& arguments,
139 SkASSERT(arguments[0]);
140 SkASSERT(!arguments[1]);
141 type_check_expression<T>(*arguments[0]);
143 return coalesce_n_way_vector(arguments[0], /*arg1=*/nullptr,
148 static std::unique_ptr<Expression> coalesce_pairwise_vectors(const IntrinsicArguments& arguments,
153 SkASSERT(arguments[0]);
154 SkASSERT(arguments[1]);
155 SkASSERT(!arguments[2]);
156 type_check_expression<T>(*arguments[0]);
157 type_check_expression<T>(*arguments[1]);
159 return coalesce_n_way_vector(arguments[0], arguments[1],
166 const IntrinsicArguments& arguments,
168 const Expression* left = arguments[0];
169 const Expression* right = arguments[1];
172 SkASSERT(!arguments[2]);
201 // Takes up to three arguments and evaluates all of them, left-to-right, in tandem.
208 // If an argument is null, zero is passed to the evaluation function. If the arguments are a mix
250 const IntrinsicArguments& arguments,
253 SkASSERT(arguments[0]);
254 SkASSERT(!arguments[1]);
255 type_check_expression<T>(*arguments[0]);
257 return evaluate_n_way_intrinsic(context, arguments[0], /*arg1=*/nullptr, /*arg2=*/nullptr,
262 const IntrinsicArguments& arguments,
265 SkASSERT(arguments[0]);
266 SkASSERT(!arguments[1]);
267 const Type& type = arguments[0]->type().componentType();
270 return evaluate_intrinsic<float>(context, arguments, returnType, eval);
273 return evaluate_intrinsic<SKSL_INT>(context, arguments, returnType, eval);
281 const IntrinsicArguments& arguments,
284 SkASSERT(arguments[0]);
285 SkASSERT(arguments[1]);
286 SkASSERT(!arguments[2]);
287 const Type& type = arguments[0]->type().componentType();
290 type_check_expression<float>(*arguments[0]);
291 type_check_expression<float>(*arguments[1]);
293 type_check_expression<SKSL_INT>(*arguments[0]);
294 type_check_expression<SKSL_INT>(*arguments[1]);
300 return evaluate_n_way_intrinsic(context, arguments[0], arguments[1], /*arg2=*/nullptr,
305 const IntrinsicArguments& arguments,
308 SkASSERT(arguments[0]);
309 SkASSERT(arguments[1]);
310 SkASSERT(arguments[2]);
311 const Type& type = arguments[0]->type().componentType();
314 type_check_expression<float>(*arguments[0]);
315 type_check_expression<float>(*arguments[1]);
316 type_check_expression<float>(*arguments[2]);
318 type_check_expression<SKSL_INT>(*arguments[0]);
319 type_check_expression<SKSL_INT>(*arguments[1]);
320 type_check_expression<SKSL_INT>(*arguments[2]);
326 return evaluate_n_way_intrinsic(context, arguments[0], arguments[1], arguments[2],
438 IntrinsicArguments arguments = {};
439 SkASSERT(argArray.size() <= arguments.size());
441 arguments[index] = ConstantFolder::GetConstantValueForVariable(*argArray[index]);
445 return *arguments[idx]->getConstantValue(col);
452 return evaluate_intrinsic<float>(context, arguments, returnType,
455 return evaluate_intrinsic<float>(context, arguments, returnType,
458 return evaluate_intrinsic<float>(context, arguments, returnType,
461 return evaluate_intrinsic<float>(context, arguments, returnType,
464 return evaluate_intrinsic<float>(context, arguments, returnType,
467 return evaluate_intrinsic<float>(context, arguments, returnType,
470 return evaluate_intrinsic<float>(context, arguments, returnType,
473 return evaluate_intrinsic<float>(context, arguments, returnType,
476 return evaluate_intrinsic<float>(context, arguments, returnType,
479 return evaluate_intrinsic<float>(context, arguments, returnType,
483 return evaluate_intrinsic<float>(context, arguments, returnType,
486 return evaluate_pairwise_intrinsic(context, arguments, returnType,
490 return evaluate_intrinsic<float>(context, arguments, returnType,
494 return evaluate_intrinsic<float>(context, arguments, returnType,
497 return evaluate_intrinsic<float>(context, arguments, returnType,
501 return evaluate_pairwise_intrinsic(context, arguments, returnType,
504 return evaluate_intrinsic<float>(context, arguments, returnType,
507 return evaluate_intrinsic<float>(context, arguments, returnType,
510 return evaluate_intrinsic<float>(context, arguments, returnType,
513 return evaluate_intrinsic<float>(context, arguments, returnType,
516 return evaluate_intrinsic<float>(context, arguments, returnType,
519 return evaluate_intrinsic<float>(context, arguments, returnType,
523 return evaluate_intrinsic_numeric(context, arguments, returnType,
526 return evaluate_intrinsic_numeric(context, arguments, returnType,
529 return evaluate_intrinsic<float>(context, arguments, returnType,
532 return evaluate_intrinsic<float>(context, arguments, returnType,
535 return evaluate_intrinsic<float>(context, arguments, returnType,
538 return evaluate_pairwise_intrinsic(context, arguments, returnType,
541 return evaluate_pairwise_intrinsic(context, arguments, returnType,
544 return evaluate_pairwise_intrinsic(context, arguments, returnType,
547 return evaluate_3_way_intrinsic(context, arguments, returnType,
550 return evaluate_intrinsic<float>(context, arguments, returnType,
553 if (arguments[2]->type().componentType().isBoolean()) {
554 const SkSL::Type& numericType = arguments[0]->type().componentType();
557 type_check_expression<float>(*arguments[0]);
558 type_check_expression<float>(*arguments[1]);
560 type_check_expression<SKSL_INT>(*arguments[0]);
561 type_check_expression<SKSL_INT>(*arguments[1]);
563 type_check_expression<bool>(*arguments[0]);
564 type_check_expression<bool>(*arguments[1]);
569 return evaluate_n_way_intrinsic(context, arguments[0], arguments[1], arguments[2],
572 return evaluate_3_way_intrinsic(context, arguments, returnType,
576 return evaluate_pairwise_intrinsic(context, arguments, returnType,
579 return evaluate_3_way_intrinsic(context, arguments, returnType,
582 return evaluate_intrinsic<float>(context, arguments, returnType,
586 return evaluate_intrinsic<float>(context, arguments, returnType,
589 return evaluate_intrinsic<float>(context, arguments, returnType,
592 return evaluate_intrinsic<float>(context, arguments, returnType,
595 return evaluate_intrinsic<SKSL_INT>(context, arguments, returnType,
598 return evaluate_intrinsic<SKSL_INT>(context, arguments, returnType,
610 SKSL_INT x = *arguments[0]->getConstantValue(0);
616 return coalesce_vector<float>(arguments, /*startingState=*/0, returnType,
620 return coalesce_pairwise_vectors<float>(arguments, /*startingState=*/0, returnType,
624 return coalesce_pairwise_vectors<float>(arguments, /*startingState=*/0, returnType,
630 SkASSERT(arguments[0]->type().columns() == 3); // the vec2 form is not a real intrinsic
635 return assemble_compound(context, arguments[0]->fLine, returnType, vec);
638 auto Vec = [&] { return DSLExpression{arguments[0]->clone()}; };
642 auto N = [&] { return DSLExpression{arguments[0]->clone()}; };
643 auto I = [&] { return DSLExpression{arguments[1]->clone()}; };
644 auto NRef = [&] { return DSLExpression{arguments[2]->clone()}; };
648 auto I = [&] { return DSLExpression{arguments[0]->clone()}; };
649 auto N = [&] { return DSLExpression{arguments[1]->clone()}; };
653 auto I = [&] { return DSLExpression{arguments[0]->clone()}; };
654 auto N = [&] { return DSLExpression{arguments[1]->clone()}; };
655 auto Eta = [&] { return DSLExpression{arguments[2]->clone()}; };
670 return evaluate_pairwise_intrinsic(context, arguments, returnType,
680 return assemble_compound(context, arguments[0]->fLine, returnType, mat);
690 return assemble_compound(context, arguments[0]->fLine, returnType, mat);
694 extract_matrix(arguments[0], mat);
696 switch (arguments[0]->type().slotCount()) {
707 SkDEBUGFAILF("unsupported type %s", arguments[0]->type().description().c_str());
710 return Literal::MakeFloat(arguments[0]->fLine, determinant, &returnType);
714 extract_matrix(arguments[0], mat);
715 switch (arguments[0]->type().slotCount()) {
732 SkDEBUGFAILF("unsupported type %s", arguments[0]->type().description().c_str());
738 return assemble_compound(context, arguments[0]->fLine, returnType, dmat);
742 return optimize_comparison(context, arguments, Intrinsics::compare_lessThan);
745 return optimize_comparison(context, arguments, Intrinsics::compare_lessThanEqual);
748 return optimize_comparison(context, arguments, Intrinsics::compare_greaterThan);
751 return optimize_comparison(context, arguments, Intrinsics::compare_greaterThanEqual);
754 return optimize_comparison(context, arguments, Intrinsics::compare_equal);
757 return optimize_comparison(context, arguments, Intrinsics::compare_notEqual);
760 return coalesce_vector<bool>(arguments, /*startingState=*/false, returnType,
764 return coalesce_vector<bool>(arguments, /*startingState=*/true, returnType,
768 return evaluate_intrinsic<bool>(context, arguments, returnType,
780 for (const auto& arg : this->arguments()) {
790 cloned.reserve_back(this->arguments().size());
791 for (const std::unique_ptr<Expression>& arg : this->arguments()) {
801 for (const std::unique_ptr<Expression>& arg : this->arguments()) {
811 * Determines the cost of coercing the arguments of a function to the required types. Cost has no
816 const ExpressionArray& arguments){
821 if (function.parameters().size() != arguments.size()) {
826 if (!function.determineFinalTypes(arguments, &types, &ignored)) {
830 for (size_t i = 0; i < arguments.size(); i++) {
831 total = total + arguments[i]->coercionCost(*types[i]);
839 const ExpressionArray& arguments) {
846 CoercionCost cost = CallCost(context, *f, arguments);
858 ExpressionArray arguments) {
864 std::move(arguments));
868 if (count != (int) arguments.size()) {
871 " arguments, but found " + to_string((int)arguments.size()));
879 arguments[i] = types[i]->coerceExpression(std::move(arguments[i]), context);
880 if (!arguments[i]) {
884 return std::make_unique<ExternalFunctionCall>(line, &f, std::move(arguments));
890 arguments);
892 return FunctionCall::Convert(context, line, *best, std::move(arguments));
896 for (size_t i = 0; i < arguments.size(); i++) {
899 msg += arguments[i]->type().displayName();
907 arguments.push_back(std::move(ref.self()));
911 arguments);
913 return FunctionCall::Convert(context, line, *best, std::move(arguments));
915 String msg = "no match for " + arguments.back()->type().displayName() +
918 for (size_t i = 0; i < arguments.size() - 1; i++) {
921 msg += arguments[i]->type().displayName();
938 ExpressionArray arguments) {
945 // Reject function calls with the wrong number of arguments.
946 if (function.parameters().size() != arguments.size()) {
952 msg += ", but found " + to_string(arguments.count());
960 if (!function.determineFinalTypes(arguments, &types, &returnType)) {
963 for (const std::unique_ptr<Expression>& arg : arguments) {
973 for (size_t i = 0; i < arguments.size(); i++) {
975 arguments[i] = types[i]->coerceExpression(std::move(arguments[i]), context);
976 if (!arguments[i]) {
985 if (!Analysis::UpdateVariableRefKind(arguments[i].get(), refKind, context.fErrors)) {
994 const Variable& child = *arguments.back()->as<VariableReference>().variable();
995 arguments.pop_back();
996 return ChildCall::Make(context, line, returnType, child, std::move(arguments));
999 return Make(context, line, returnType, function, std::move(arguments));
1006 ExpressionArray arguments) {
1007 SkASSERT(function.parameters().size() == arguments.size());
1010 if (function.isIntrinsic() && has_compile_time_constant_arguments(arguments)) {
1014 arguments,
1020 return std::make_unique<FunctionCall>(line, returnType, &function, std::move(arguments));