LVX	(rtmp)(R1), V30       \
	MOVD	$(offset+16*11), rtmp \
	LVX	(rtmp)(R1), V31

// LR and CR are saved in the caller's frame. The callee must
// make space for all other callee-save registers.
#define SAVE_ALL_REG_SIZE (SAVE_GPR_SIZE+SAVE_FPR_SIZE+SAVE_VR_SIZE)

// Stack a frame and save all callee-save registers following the
// host OS's ABI. Fortunately, this is identical for AIX, ELFv1, and

      }
      llvm::SmallVector<func::FuncOp> callees;
      if (GetCallees(op, symtab, callees).failed()) {
        return WalkResult::interrupt();
      }
      for (auto callee : callees) {
        worklist.push(callee);
      }
      return WalkResult::advance();
    });
    if (result.wasInterrupted()) return failure();
  }
  return success();
}

package main

const p0exp = "foo"
const p1exp = 10101
const p2exp = 3030303
const p3exp = 505050505
const p4exp = 70707070707

//go:noinline
//go:registerparams
func callee(p0 string, p1 uint64, p2 uint64, p3 uint64, p4 uint64) {
	if p0 != p0exp {
		panic("bad p0")
	}
	if p1 != p1exp {
		panic("bad p1")
	}
	if p2 != p2exp {
		panic("bad p2")
	}
	if p3 != p3exp {

          ArrayRef<func::FuncOp> callees, const PerFunctionResult& caller_res) {
        for (func::FuncOp callee : callees) {
          assert(callee);
          auto& callee_res = per_function_results.find(callee)->getSecond();
          bool callee_needs_recompute = false;
          for (BlockArgument arg : filter_resources(callee.getArguments())) {
            Value arg_operand = caller_operands[arg.getArgNumber()];

    }
  }
}
versions {
  producer: 29
  min_consumer: 12
}

# Find PartitionedCall ops in main and match the callee name.
# CHECK: func @main
# CHECK: "tf.PartitionedCall"
# CHECK-SAME: f = @[[FUNCTION_FOO:[a-zA-Z0-9_]*]]

# Find callee and verify it has the stateful attribute set.
# CHECK: func private @[[FUNCTION_FOO]]
# CHECK-SAME: attributes

  // CHECK-SAME: callee = @main_stream_0
  %handle_0 = mlrt.async(%input0, %promise_b)
    {callee = @main_stream_0} :
    (tensor<i32>, !mlrt.promise) -> !mlrt.async_handle
  // CHECK: [[handle_1:%.*]] = mlrt.async([[input1]], [[promises]]#1, [[promises]]#2)
  // CHECK-SAME: callee = @main_stream_1
  %handle_1 = mlrt.async(%input1, %promise_c, %promise_d)
    {callee = @main_stream_1} :

      value {
      }
    }
  }
}
versions {
  producer: 85
  min_consumer: 12
}

# Match partitioned call in main and capture the callee name.
# CHECK-LABEL: func @main
# CHECK: tf.PartitionedCall
# CHECK-SAME: f = @[[FUNCTION:[a-zA-Z0-9_]*]]

# Verify that callee has the unit attribute tf._input_shapes.
# CHECK: func private @[[FUNCTION]]
# CHECK: attributes

		if !ok {
			break
		}
		if strings.ContainsAny(caller, " \r\n") {
			t.Skip("caller contains space or newline")
		}

		callee, ok := consumeString()
		if !ok {
			break
		}
		if strings.ContainsAny(callee, " \r\n") {
			t.Skip("callee contains space or newline")
		}

		line, ok := consumeInt64()
		if !ok {
			break
		}
		weight, ok := consumeInt64()
		if !ok {

  if (lowered_callee != callee) {
    if (!info.signature_change) {
      // Signature is not modified. We do not need to keep two copies.
      lowered_callee.setName(
          StringAttr::get(callee->getContext(), callee.getName()));
      callee.erase();
    } else {
      // Add the clone with a new name.
      lowered_callee.setName(StringAttr::get(
          callee->getContext(),

    ```Python hl_lines="15"
    {!> ../../../docs_src/dependencies/tutorial012.py!}
    ```

Und alle Ideen aus dem Abschnitt über das [Hinzufügen von `dependencies` zu den *Pfadoperation-Dekoratoren*](dependencies-in-path-operation-decorators.md){.internal-link target=_blank} gelten weiterhin, aber in diesem Fall für alle *Pfadoperationen* in der Anwendung.

## Abhängigkeiten für Gruppen von *Pfadoperationen*