DCHECK(num_dims >= 0) << "Number of dimensions cannot be negative!";
  shape.num_dims = num_dims;
  shape.dims = new int64_t[num_dims];
  memcpy(shape.dims, dims, sizeof(int64_t) * num_dims);
}

void TF_ShapeAndTypeListSetUnknownShape(TF_ShapeAndTypeList* shape_list,
                                        int index) {
  DCHECK(index >= 0 && index < shape_list->num_items);

pkg go/types, type SelectionKind int
pkg go/types, type Signature struct
pkg go/types, type Sizes interface { Alignof, Offsetsof, Sizeof }
pkg go/types, type Sizes interface, Alignof(Type) int64
pkg go/types, type Sizes interface, Offsetsof([]*Var) []int64
pkg go/types, type Sizes interface, Sizeof(Type) int64
pkg go/types, type Slice struct
pkg go/types, type StdSizes struct
pkg go/types, type StdSizes struct, MaxAlign int64

package cmd

import (
	"bytes"
	"fmt"
	"syscall"
	"unsafe"
)

func direntNamlen(dirent *syscall.Dirent) (uint64, error) {
	const fixedHdr = uint16(unsafe.Offsetof(syscall.Dirent{}.Name))
	nameBuf := (*[unsafe.Sizeof(dirent.Name)]byte)(unsafe.Pointer(&dirent.Name[0]))
	const nameBufLen = uint16(len(nameBuf))
	limit := dirent.Reclen - fixedHdr
	if limit > nameBufLen {
		limit = nameBufLen
	}
	// Avoid bugs in long file names

      TF_Tensor* out = csession.output_tensor(i);
      ASSERT_TRUE(out != nullptr);
      EXPECT_EQ(TF_INT32, TF_TensorType(out));
      EXPECT_EQ(0, TF_NumDims(out));  // scalar
      ASSERT_EQ(sizeof(int32_t), TF_TensorByteSize(out));
      int32_t* output_contents = static_cast<int32_t*>(TF_TensorData(out));
      EXPECT_EQ(expected_results[i], *output_contents);
    }
  }

		0, // u6
		f7,
		f8,
		0, // s9
		0, // s10
		1
	};

	const char __cgodebug_str__9[] = s9;
	const unsigned long long __cgodebug_strlen__9 = sizeof(s9)-1;
	const char __cgodebug_str__10[] = s10;
	const unsigned long long __cgodebug_strlen__10 = sizeof(s10)-1;

and again invokes the system C compiler, to produce an object file
containing debug information. Cgo parses the DWARF debug information

func parseDirEnt(buf []byte) (consumed int, name []byte, typ os.FileMode, err error) {
	// golang.org/issue/15653
	dirent := (*syscall.Dirent)(unsafe.Pointer(&buf[0]))
	if v := unsafe.Offsetof(dirent.Reclen) + unsafe.Sizeof(dirent.Reclen); uintptr(len(buf)) < v {
		return consumed, nil, typ, fmt.Errorf("buf size of %d smaller than dirent header size %d", len(buf), v)
	}
	if len(buf) < int(dirent.Reclen) {

     * @return the estimated memory size in bytes
     */
    public long calculateDocumentSize(final Map<String, Object> dataMap) {
        return MemoryUtil.sizeOf(dataMap);
    }

    /**
     * Sets the maximum number of retry attempts for failed operations.
     *
     * @param maxRetryCount the maximum retry count
     */

  GraphImportGraphDefLocked(graph, def, options, &results, status);
  DCHECK_EQ(results.return_tensors.size(), num_return_outputs);
  memcpy(return_outputs, results.return_tensors.data(),
         num_return_outputs * sizeof(TF_Output));
}

void TF_GraphImportGraphDef(TF_Graph* graph, const TF_Buffer* graph_def,
                            const TF_ImportGraphDefOptions* options,
                            TF_Status* status) {

a <a href="#Conversions">conversion</a> with a result that is a constant, or
the result value of some built-in functions such as
<code>min</code> or <code>max</code> applied to constant arguments,
<code>unsafe.Sizeof</code> applied to <a href="#Package_unsafe">certain values</a>,
<code>cap</code> or <code>len</code> applied to
<a href="#Length_and_capacity">some expressions</a>,

nil { t.Fatalf("mprotect low failed %s\n", err) } err = syscall.Mprotect(b[2*pagesize:], syscall.PROT_NONE) if err != nil { t.Fatalf("mprotect high failed %s\n", err) } b = b[pagesize : 2*pagesize] end = (*T)(unsafe.Pointer(&b[len(b)-(int)(unsafe.Sizeof(*end))])) start = (*T)(unsafe.Pointer(&b[0])) return start, end } func TestP256SelectAffine(t *testing.T) { var out p256AffinePoint begintp, endtp := dangerousObjs[p256AffineTable](t) for i := 0; i < 31; i++ { p256SelectAffine(&out, begintp, i) p...