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 // It is also valid to use &^ to round pointers, usually for alignment. 81 // In all cases, the result must continue to point into the original allocated object. 82 // 83 // Unlike in C, it is not valid to advance a pointer just beyond the end of 84 // its original allocation: 85 // 86 // // INVALID: end points outside allocated space. 87 // var s thing 88 // end = unsafe.Pointer(uintptr(unsafe.Pointer(&s)) + unsafe.Sizeof(s)) 89 // 90 // // INVALID: end points outside allocated space. 91 // b := make([]byte, n) 92 // end = unsafe.Pointer(uintptr(unsafe.Pointer(&b[0])) + uintptr(n)) 93 // 94 // Note that both conversions must appear in the same expression, with only 95 // the intervening arithmetic between them: 96 // 97 // // INVALID: uintptr cannot be stored in variable 98 // // before conversion back to Pointer. 99 // u := uintptr(p) 100 // p = unsafe.Pointer(u + offset) 101 // 102 // Note that the pointer must point into an allocated object, so it may not be nil. 103 // 104 // // INVALID: conversion of nil pointer 105 // u := unsafe.Pointer(nil) 106 // p := unsafe.Pointer(uintptr(u) + offset) 107 // 108 // (4) Conversion of a Pointer to a uintptr when calling syscall.Syscall. 109 // 110 // The Syscall functions in package syscall pass their uintptr arguments directly 111 // to the operating system, which then may, depending on the details of the call, 112 // reinterpret some of them as pointers. 113 // That is, the system call implementation is implicitly converting certain arguments 114 // back from uintptr to pointer. 115 // 116 // If a pointer argument must be converted to uintptr for use as an argument, 117 // that conversion must appear in the call expression itself: 118 // 119 // syscall.Syscall(SYS_READ, uintptr(fd), uintptr(unsafe.Pointer(p)), uintptr(n)) 120 // 121 // The compiler handles a Pointer converted to a uintptr in the argument list of 122 // a call to a function implemented in assembly by arranging that the referenced 123 // allocated object, if any, is retained and not moved until the call completes, 124 // even though from the types alone it would appear that the object is no longer 125 // needed during the call. 126 // 127 // For the compiler to recognize this pattern, 128 // the conversion must appear in the argument list: 129 // 130 // // INVALID: uintptr cannot be stored in variable 131 // // before implicit conversion back to Pointer during system call. 132 // u := uintptr(unsafe.Pointer(p)) 133 // syscall.Syscall(SYS_READ, uintptr(fd), u, uintptr(n)) 134 // 135 // (5) Conversion of the result of reflect.Value.Pointer or reflect.Value.UnsafeAddr 136 // from uintptr to Pointer. 137 // 138 // Package reflect's Value methods named Pointer and UnsafeAddr return type uintptr 139 // instead of unsafe.Pointer to keep callers from changing the result to an arbitrary 140 // type without first importing "unsafe". However, this means that the result is 141 // fragile and must be converted to Pointer immediately after making the call, 142 // in the same expression: 143 // 144 // p := (*int)(unsafe.Pointer(reflect.ValueOf(new(int)).Pointer())) 145 // 146 // As in the cases above, it is invalid to store the result before the conversion: 147 // 148 // // INVALID: uintptr cannot be stored in variable 149 // // before conversion back to Pointer. 150 // u := reflect.ValueOf(new(int)).Pointer() 151 // p := (*int)(unsafe.Pointer(u)) 152 // 153 // (6) Conversion of a reflect.SliceHeader or reflect.StringHeader Data field to or from Pointer. 154 // 155 // As in the previous case, the reflect data structures SliceHeader and StringHeader 156 // declare the field Data as a uintptr to keep callers from changing the result to 157 // an arbitrary type without first importing "unsafe". However, this means that 158 // SliceHeader and StringHeader are only valid when interpreting the content 159 // of an actual slice or string value. 160 // 161 // var s string 162 // hdr := (*reflect.StringHeader)(unsafe.Pointer(&s)) // case 1 163 // hdr.Data = uintptr(unsafe.Pointer(p)) // case 6 (this case) 164 // hdr.Len = n 165 // 166 // In this usage hdr.Data is really an alternate way to refer to the underlying 167 // pointer in the string header, not a uintptr variable itself. 168 // 169 // In general, reflect.SliceHeader and reflect.StringHeader should be used 170 // only as *reflect.SliceHeader and *reflect.StringHeader pointing at actual 171 // slices or strings, never as plain structs. 172 // A program should not declare or allocate variables of these struct types. 173 // 174 // // INVALID: a directly-declared header will not hold Data as a reference. 175 // var hdr reflect.StringHeader 176 // hdr.Data = uintptr(unsafe.Pointer(p)) 177 // hdr.Len = n 178 // s := *(*string)(unsafe.Pointer(&hdr)) // p possibly already lost 179 // 180 type Pointer *ArbitraryType 181 182 // Sizeof takes an expression x of any type and returns the size in bytes 183 // of a hypothetical variable v as if v was declared via var v = x. 184 // The size does not include any memory possibly referenced by x. 185 // For instance, if x is a slice, Sizeof returns the size of the slice 186 // descriptor, not the size of the memory referenced by the slice. 187 // The return value of Sizeof is a Go constant. 188 func Sizeof(x ArbitraryType) uintptr 189 190 // Offsetof returns the offset within the struct of the field represented by x, 191 // which must be of the form structValue.field. In other words, it returns the 192 // number of bytes between the start of the struct and the start of the field. 193 // The return value of Offsetof is a Go constant. 194 func Offsetof(x ArbitraryType) uintptr 195 196 // Alignof takes an expression x of any type and returns the required alignment 197 // of a hypothetical variable v as if v was declared via var v = x. 198 // It is the largest value m such that the address of v is always zero mod m. 199 // It is the same as the value returned by reflect.TypeOf(x).Align(). 200 // As a special case, if a variable s is of struct type and f is a field 201 // within that struct, then Alignof(s.f) will return the required alignment 202 // of a field of that type within a struct. This case is the same as the 203 // value returned by reflect.TypeOf(s.f).FieldAlign(). 204 // The return value of Alignof is a Go constant. 205 func Alignof(x ArbitraryType) uintptr 206