...
Run Format

Source file src/unsafe/unsafe.go

     1	// Copyright 2009 The Go Authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style
     3	// license that can be found in the LICENSE file.
     4	
     5	/*
     6		Package unsafe contains operations that step around the type safety of Go programs.
     7	
     8		Packages that import unsafe may be non-portable and are not protected by the
     9		Go 1 compatibility guidelines.
    10	*/
    11	package unsafe
    12	
    13	// ArbitraryType is here for the purposes of documentation only and is not actually
    14	// part of the unsafe package. It represents the type of an arbitrary Go expression.
    15	type ArbitraryType int
    16	
    17	// Pointer represents a pointer to an arbitrary type. There are four special operations
    18	// available for type Pointer that are not available for other types:
    19	//	- A pointer value of any type can be converted to a Pointer.
    20	//	- A Pointer can be converted to a pointer value of any type.
    21	//	- A uintptr can be converted to a Pointer.
    22	//	- A Pointer can be converted to a uintptr.
    23	// Pointer therefore allows a program to defeat the type system and read and write
    24	// arbitrary memory. It should be used with extreme care.
    25	//
    26	// The following patterns involving Pointer are valid.
    27	// Code not using these patterns is likely to be invalid today
    28	// or to become invalid in the future.
    29	// Even the valid patterns below come with important caveats.
    30	//
    31	// Running "go vet" can help find uses of Pointer that do not conform to these patterns,
    32	// but silence from "go vet" is not a guarantee that the code is valid.
    33	//
    34	// (1) Conversion of a *T1 to Pointer to *T2.
    35	//
    36	// Provided that T2 is no larger than T1 and that the two share an equivalent
    37	// memory layout, this conversion allows reinterpreting data of one type as
    38	// data of another type. An example is the implementation of
    39	// math.Float64bits:
    40	//
    41	//	func Float64bits(f float64) uint64 {
    42	//		return *(*uint64)(unsafe.Pointer(&f))
    43	//	}
    44	//
    45	// (2) Conversion of a Pointer to a uintptr (but not back to Pointer).
    46	//
    47	// Converting a Pointer to a uintptr produces the memory address of the value
    48	// pointed at, as an integer. The usual use for such a uintptr is to print it.
    49	//
    50	// Conversion of a uintptr back to Pointer is not valid in general.
    51	//
    52	// A uintptr is an integer, not a reference.
    53	// Converting a Pointer to a uintptr creates an integer value
    54	// with no pointer semantics.
    55	// Even if a uintptr holds the address of some object,
    56	// the garbage collector will not update that uintptr's value
    57	// if the object moves, nor will that uintptr keep the object
    58	// from being reclaimed.
    59	//
    60	// The remaining patterns enumerate the only valid conversions
    61	// from uintptr to Pointer.
    62	//
    63	// (3) Conversion of a Pointer to a uintptr and back, with arithmetic.
    64	//
    65	// If p points into an allocated object, it can be advanced through the object
    66	// by conversion to uintptr, addition of an offset, and conversion back to Pointer.
    67	//
    68	//	p = unsafe.Pointer(uintptr(p) + offset)
    69	//
    70	// The most common use of this pattern is to access fields in a struct
    71	// or elements of an array:
    72	//
    73	//	// equivalent to f := unsafe.Pointer(&s.f)
    74	//	f := unsafe.Pointer(uintptr(unsafe.Pointer(&s)) + unsafe.Offsetof(s.f))
    75	//
    76	//	// equivalent to e := unsafe.Pointer(&x[i])
    77	//	e := unsafe.Pointer(uintptr(unsafe.Pointer(&x[0])) + i*unsafe.Sizeof(x[0]))
    78	//
    79	// It is valid both to add and to subtract offsets from a pointer in this way,
    80	// but the result must continue to point into the original allocated object.
    81	// Unlike in C, it is not valid to advance a pointer just beyond the end of
    82	// its original allocation:
    83	//
    84	//	// INVALID: end points outside allocated space.
    85	//	var s thing
    86	//	end = unsafe.Pointer(uintptr(unsafe.Pointer(&s)) + unsafe.Sizeof(s))
    87	//
    88	//	// INVALID: end points outside allocated space.
    89	//	b := make([]byte, n)
    90	//	end = unsafe.Pointer(uintptr(unsafe.Pointer(&b[0])) + uintptr(n))
    91	//
    92	// Note that both conversions must appear in the same expression, with only
    93	// the intervening arithmetic between them:
    94	//
    95	//	// INVALID: uintptr cannot be stored in variable
    96	//	// before conversion back to Pointer.
    97	//	u := uintptr(p)
    98	//	p = unsafe.Pointer(u + offset)
    99	//
   100	// (4) Conversion of a Pointer to a uintptr when calling syscall.Syscall.
   101	//
   102	// The Syscall functions in package syscall pass their uintptr arguments directly
   103	// to the operating system, which then may, depending on the details of the call,
   104	// reinterpret some of them as pointers.
   105	// That is, the system call implementation is implicitly converting certain arguments
   106	// back from uintptr to pointer.
   107	//
   108	// If a pointer argument must be converted to uintptr for use as an argument,
   109	// that conversion must appear in the call expression itself:
   110	//
   111	//	syscall.Syscall(SYS_READ, uintptr(fd), uintptr(unsafe.Pointer(p)), uintptr(n))
   112	//
   113	// The compiler handles a Pointer converted to a uintptr in the argument list of
   114	// a call to a function implemented in assembly by arranging that the referenced
   115	// allocated object, if any, is retained and not moved until the call completes,
   116	// even though from the types alone it would appear that the object is no longer
   117	// needed during the call.
   118	//
   119	// For the compiler to recognize this pattern,
   120	// the conversion must appear in the argument list:
   121	//
   122	//	// INVALID: uintptr cannot be stored in variable
   123	//	// before implicit conversion back to Pointer during system call.
   124	//	u := uintptr(unsafe.Pointer(p))
   125	//	syscall.Syscall(SYS_READ, uintptr(fd), u, uintptr(n))
   126	//
   127	// (5) Conversion of the result of reflect.Value.Pointer or reflect.Value.UnsafeAddr
   128	// from uintptr to Pointer.
   129	//
   130	// Package reflect's Value methods named Pointer and UnsafeAddr return type uintptr
   131	// instead of unsafe.Pointer to keep callers from changing the result to an arbitrary
   132	// type without first importing "unsafe". However, this means that the result is
   133	// fragile and must be converted to Pointer immediately after making the call,
   134	// in the same expression:
   135	//
   136	//	p := (*int)(unsafe.Pointer(reflect.ValueOf(new(int)).Pointer()))
   137	//
   138	// As in the cases above, it is invalid to store the result before the conversion:
   139	//
   140	//	// INVALID: uintptr cannot be stored in variable
   141	//	// before conversion back to Pointer.
   142	//	u := reflect.ValueOf(new(int)).Pointer()
   143	//	p := (*int)(unsafe.Pointer(u))
   144	//
   145	// (6) Conversion of a reflect.SliceHeader or reflect.StringHeader Data field to or from Pointer.
   146	//
   147	// As in the previous case, the reflect data structures SliceHeader and StringHeader
   148	// declare the field Data as a uintptr to keep callers from changing the result to
   149	// an arbitrary type without first importing "unsafe". However, this means that
   150	// SliceHeader and StringHeader are only valid when interpreting the content
   151	// of an actual slice or string value.
   152	//
   153	//	var s string
   154	//	hdr := (*reflect.StringHeader)(unsafe.Pointer(&s)) // case 1
   155	//	hdr.Data = uintptr(unsafe.Pointer(p))              // case 6 (this case)
   156	//	hdr.Len = uintptr(n)
   157	//
   158	// In this usage hdr.Data is really an alternate way to refer to the underlying
   159	// pointer in the slice header, not a uintptr variable itself.
   160	//
   161	// In general, reflect.SliceHeader and reflect.StringHeader should be used
   162	// only as *reflect.SliceHeader and *reflect.StringHeader pointing at actual
   163	// slices or strings, never as plain structs.
   164	// A program should not declare or allocate variables of these struct types.
   165	//
   166	//	// INVALID: a directly-declared header will not hold Data as a reference.
   167	//	var hdr reflect.StringHeader
   168	//	hdr.Data = uintptr(unsafe.Pointer(p))
   169	//	hdr.Len = uintptr(n)
   170	//	s := *(*string)(unsafe.Pointer(&hdr)) // p possibly already lost
   171	//
   172	type Pointer *ArbitraryType
   173	
   174	// Sizeof takes an expression x of any type and returns the size in bytes
   175	// of a hypothetical variable v as if v was declared via var v = x.
   176	// The size does not include any memory possibly referenced by x.
   177	// For instance, if x is a slice,  Sizeof returns the size of the slice
   178	// descriptor, not the size of the memory referenced by the slice.
   179	func Sizeof(x ArbitraryType) uintptr
   180	
   181	// Offsetof returns the offset within the struct of the field represented by x,
   182	// which must be of the form structValue.field. In other words, it returns the
   183	// number of bytes between the start of the struct and the start of the field.
   184	func Offsetof(x ArbitraryType) uintptr
   185	
   186	// Alignof takes an expression x of any type and returns the required alignment
   187	// of a hypothetical variable v as if v was declared via var v = x.
   188	// It is the largest value m such that the address of v is always zero mod m.
   189	// It is the same as the value returned by reflect.TypeOf(x).Align().
   190	// As a special case, if a variable s is of struct type and f is a field
   191	// within that struct, then Alignof(s.f) will return the required alignment
   192	// of a field of that type within a struct. This case is the same as the
   193	// value returned by reflect.TypeOf(s.f).FieldAlign().
   194	func Alignof(x ArbitraryType) uintptr
   195	

View as plain text