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

// Issue 4348. After switch to 64-bit ints the compiler generates
// illegal instructions when using large array bounds or indexes.

// Skip. We reject symbols larger that 2GB (Issue #9862).

package main

// 1<<32 on a 64-bit machine, 1 otherwise.
const LARGE = ^uint(0)>>32 + 1

func A() int {
	var a []int
	return a[LARGE]
}

var b [LARGE]int

func B(i int) int {

`experimental_image_format` option:

```
tf.savedmodel.save(
    model, path,
    options=tf.saved_model.SaveOptions(experimental_image_format=True)
)
```

When this option is enabled, exported SavedModels with proto size > 2GB will
automatically save with the new format (`.cpb` instead of `.pb`).

<!-- **Compatibility** -->

The official TF APIs (TF1/TF2 python or C++ loading) have already been

// Argument/return areas are part of the parent frame, not the frame itself,
// so they need to be handled separately.

package main

// >1GB to trigger failure, <2GB to work on 32-bit platforms.
type large struct {
	b [1500000000]byte
}

func (x large) f1() int { // GC_ERROR "stack frame too large"
	return 5
}

func f2(x large) int { // GC_ERROR "stack frame too large"

#if !IS_OSS
absl::StatusOr<std::tuple<absl::Cord, bool>> WriteSavedModelToCord(
    SavedModel* saved_model_proto);
#endif

// See above. The `debug_max_size` argument can be used to the maximum size to
// less than 2GB for testing purposes.
absl::Status WriteSavedModel(SavedModel* saved_model_proto,
                             const std::string& file_prefix,
                             int debug_max_size);

}  // namespace image_format

	return syscall.SetNonblock(fd.Sysfd, false)
}

// Darwin and FreeBSD can't read or write 2GB+ files at a time,
// even on 64-bit systems.
// The same is true of socket implementations on many systems.
// See golang.org/issue/7812 and golang.org/issue/16266.
// Use 1GB instead of, say, 2GB-1, to keep subsequent reads aligned.
const maxRW = 1 << 30

// Read implements io.Reader.

  // computation, which may require relevant metadata such as quantization
  // parameters.
  intermediates:[int];

  // When an op is using custom_options in a model that is larger than 2GB, then
  // we instead use the following attributes to find the buffer location which
  // is stored outside of flatbuffers, the offset is calculated relative to the
  // beginning of the file and is only valid if > 1

            // TODO: This breaks the provider
            task.setOutputDir(extension.getUserManual().getStagingRoot().dir("render-single-pdf").get().getAsFile());
            // The PDF rendering needs at least 2GB of heap
            task.jvm(options -> options.setMaxHeapSize("3g"));
        });

        TaskProvider<AsciidoctorTask> userguideMultiPage = tasks.register("userguideMultiPage", AsciidoctorTask.class, task -> {

  // There is a limit of 2GB for a flatbuffer.
  bool flatbuffer_limit_exceeded = builder_.GetSize() > flatbuffer_size_max;
  if (flatbuffer_limit_exceeded && require_use_buffer_offset_ == false) {
    require_use_buffer_offset_ = true;
    return std::nullopt;
  }
  if (flatbuffer_limit_exceeded) {
    LOG(ERROR) << "Model structure size is bigger than 2gb";
    return std::nullopt;
  }

	rs := r.Sym()
	if target.IsAIX() {
		ldr.Errorf(s, "archrelocaddr called for %s relocation\n", ldr.SymName(rs))
	}
	o1, o2 := unpackInstPair(target, val)

	// Verify resulting address fits within a 31 bit (2GB) address space.
	// This is a restriction arising  from the usage of lis (HA) + d-form
	// (LO) instruction sequences used to implement absolute relocations
	// on PPC64 prior to ISA 3.1 (P10). For consistency, maintain this

	// exceed Go's 48 bit limit, it's extremely unlikely in
	// practice.
	//
	// On 32-bit platforms, we accept the full 32-bit address
	// space because doing so is cheap.
	// mips32 only has access to the low 2GB of virtual memory, so
	// we further limit it to 31 bits.
	//
	// On ios/arm64, although 64-bit pointers are presumably
	// available, pointers are truncated to 33 bits in iOS <14.