// R4 contains argv, R5 contains envp, R6 contains auxv, and R13
	// contains the TLS pointer.
	//
	// When loading via glibc, the first doubleword on the stack points
	// to NULL a value. (that is *(uintptr)(R1) == 0). This is used to
	// differentiate static vs dynamically linked binaries.
	//
	// If loading with the musl loader, it doesn't follow the ELFv2 ABI. It
	// passes argc/argv similar to the linux kernel, R13 (TLS) is

apiVersion: release-notes/v2
kind: feature
area: istioctl
issue:
- 47159
releaseNotes:
- |

#include <string>

#include "tensorflow/compiler/jit/device_compiler_client.h"
#include "xla/pjrt/pjrt_client.h"

namespace tensorflow {

// Calls into PjRtClient to provide functionality for building, serializing and
// loading PjRtLoadedExecutables.
class PjRtDeviceCompilerClient
    : public DeviceCompilerClient<xla::PjRtLoadedExecutable, xla::PjRtClient> {
 public:
  explicit PjRtDeviceCompilerClient(xla::PjRtClient* client)

# Regression test for https://go.dev/issue/54712: the "unix" build constraint
# was not applied consistently during package loading.

go list -x -f '{{if .Module}}{{.ImportPath}}{{end}}' -deps .
stdout 'example.com/version'

-- go.mod --
module example

go 1.19

require example.com/version v1.1.0
-- go.sum --
example.com/version v1.1.0 h1:VdPnGmIF1NJrntStkxGrF3L/OfhaL567VzCjncGUgtM=

   * Returns a cache loader that uses {@code function} to load keys, without supporting either
   * reloading or bulk loading. This allows creating a cache loader using a lambda expression.
   *
   * <p>The returned object is serializable if {@code function} is serializable.
   *
   * @param function the function to be used for loading values; must never return {@code null}
   * @return a cache loader that loads values by passing each key to {@code function}

# 'go get'.

# The package import graph used in this test looks like:
#
# lazy ---- a
#           |
#           a_test ---- b
#                       b_test ---- c
#
# The module dependency graph initially looks like:
#
# lazy ---- a.1 ---- b.1 ---- c.1
#      \                     /
#        b.3 ---- c.2    b.2
#

// license that can be found in the LICENSE file.

// Test that we can access dynamically imported variables.
// We ues mach_task_self_ from darwin's system library.
// Check that loading the variable from C and Go gets the
// same result.

//go:build darwin

package main

/*
#include <mach/mach_init.h>

unsigned int Mach_task_self(void) {
	return mach_task_self();
}
*/

//
// There are two exported entry points into package loading — LoadPackages and
// ImportFromFiles — both implemented in terms of loadFromRoots, which itself
// manipulates an instance of the loader struct.
//
// Although most of the loading state is maintained in the loader struct,
// one key piece - the build list - is a global, so that it can be modified
// separate from the loading operation, such as during "go get"

[compiler:gccgo] skip

# If coverpkg=m/sleepy... expands by package loading
# (as opposed to pattern matching on deps)
# then it will try to load sleepybad, which does not compile,
# and the test command will fail.
! go list m/sleepy...
go test -c -n -coverprofile=$TMPDIR/cover.out -coverpkg=m/sleepy... -run=^$ m/sleepy1

-- go.mod --
module m

go 1.16
-- sleepy1/p_test.go --
package p

import (
	"testing"
	"time"
)

 * While still allowing the ToolingApiConnection to be used as a ProjectConnection.
 * This avoids loading the ProjectConnection class from the test code and postbones loading to the tooling api magic.
 */

trait ProjectConnectionTrait implements ProjectConnection {
}

class ToolingApiConnection {
    private final Object projectConnection