bb3d05169d
This interpreter currently complements the Go SSA level interpreter. It may stay complementary or may be the only interpreter in the future. This interpreter is experimental and not yet finished (there are known bugs!) so it is disabled by default. It can be enabled by passing the -initinterp flag. The goal is to be able to run all initializations at compile time except for the ones having side effects. This mostly works except perhaps for a few edge cases. In the future, this interpeter may be used to actually run regular Go code, perhaps in a shell.
588 строки
18 КиБ
Go
588 строки
18 КиБ
Go
package interp
|
|
|
|
// This file provides a litte bit of abstraction around LLVM values.
|
|
|
|
import (
|
|
"strconv"
|
|
|
|
"github.com/aykevl/go-llvm"
|
|
)
|
|
|
|
// A Value is a LLVM value with some extra methods attached for easier
|
|
// interpretation.
|
|
type Value interface {
|
|
Value() llvm.Value // returns a LLVM value
|
|
Type() llvm.Type // equal to Value().Type()
|
|
IsConstant() bool // returns true if this value is a constant value
|
|
Load() llvm.Value // dereference a pointer
|
|
Store(llvm.Value) // store to a pointer
|
|
GetElementPtr([]uint32) Value // returns an interior pointer
|
|
String() string // string representation, for debugging
|
|
}
|
|
|
|
// A type that simply wraps a LLVM constant value.
|
|
type LocalValue struct {
|
|
Eval *Eval
|
|
Underlying llvm.Value
|
|
}
|
|
|
|
// Value implements Value by returning the constant value itself.
|
|
func (v *LocalValue) Value() llvm.Value {
|
|
return v.Underlying
|
|
}
|
|
|
|
func (v *LocalValue) Type() llvm.Type {
|
|
return v.Underlying.Type()
|
|
}
|
|
|
|
func (v *LocalValue) IsConstant() bool {
|
|
return v.Underlying.IsConstant()
|
|
}
|
|
|
|
// Load loads a constant value if this is a constant GEP, otherwise it panics.
|
|
func (v *LocalValue) Load() llvm.Value {
|
|
switch v.Underlying.Opcode() {
|
|
case llvm.GetElementPtr:
|
|
indices := v.getConstGEPIndices()
|
|
if indices[0] != 0 {
|
|
panic("invalid GEP")
|
|
}
|
|
global := v.Eval.getValue(v.Underlying.Operand(0))
|
|
agg := global.Load()
|
|
return llvm.ConstExtractValue(agg, indices[1:])
|
|
default:
|
|
panic("interp: load from a constant")
|
|
}
|
|
}
|
|
|
|
// Store stores to the underlying value if the value type is a constant GEP,
|
|
// otherwise it panics.
|
|
func (v *LocalValue) Store(value llvm.Value) {
|
|
switch v.Underlying.Opcode() {
|
|
case llvm.GetElementPtr:
|
|
indices := v.getConstGEPIndices()
|
|
if indices[0] != 0 {
|
|
panic("invalid GEP")
|
|
}
|
|
global := &GlobalValue{v.Eval, v.Underlying.Operand(0)}
|
|
agg := global.Load()
|
|
agg = llvm.ConstInsertValue(agg, value, indices[1:])
|
|
global.Store(agg)
|
|
return
|
|
default:
|
|
panic("interp: store on a constant")
|
|
}
|
|
}
|
|
|
|
// GetElementPtr returns a constant GEP when the underlying value is also a
|
|
// constant GEP. It panics when the underlying value is not a constant GEP:
|
|
// getting the pointer to a constant is not possible.
|
|
func (v *LocalValue) GetElementPtr(indices []uint32) Value {
|
|
switch v.Underlying.Opcode() {
|
|
case llvm.GetElementPtr, llvm.IntToPtr:
|
|
int32Type := v.Underlying.Type().Context().Int32Type()
|
|
llvmIndices := getLLVMIndices(int32Type, indices)
|
|
return &LocalValue{v.Eval, llvm.ConstGEP(v.Underlying, llvmIndices)}
|
|
default:
|
|
panic("interp: GEP on a constant")
|
|
}
|
|
}
|
|
|
|
func (v *LocalValue) String() string {
|
|
isConstant := "false"
|
|
if v.IsConstant() {
|
|
isConstant = "true"
|
|
}
|
|
return "&LocalValue{Type: " + v.Type().String() + ", IsConstant: " + isConstant + "}"
|
|
}
|
|
|
|
// getConstGEPIndices returns indices of this constant GEP, if this is a GEP
|
|
// instruction. If it is not, the behavior is undefined.
|
|
func (v *LocalValue) getConstGEPIndices() []uint32 {
|
|
indices := make([]uint32, v.Underlying.OperandsCount()-1)
|
|
for i := range indices {
|
|
operand := v.Underlying.Operand(i + 1)
|
|
indices[i] = uint32(operand.ZExtValue())
|
|
}
|
|
return indices
|
|
}
|
|
|
|
// GlobalValue wraps a LLVM global variable.
|
|
type GlobalValue struct {
|
|
Eval *Eval
|
|
Underlying llvm.Value
|
|
}
|
|
|
|
// Value returns the initializer for this global variable.
|
|
func (v *GlobalValue) Value() llvm.Value {
|
|
return v.Underlying
|
|
}
|
|
|
|
// Type returns the type of this global variable, which is a pointer type. Use
|
|
// Type().ElementType() to get the actual global variable type.
|
|
func (v *GlobalValue) Type() llvm.Type {
|
|
return v.Underlying.Type()
|
|
}
|
|
|
|
// IsConstant returns true if this global is not dirty, false otherwise.
|
|
func (v *GlobalValue) IsConstant() bool {
|
|
if _, ok := v.Eval.dirtyGlobals[v.Underlying]; ok {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Load returns the initializer of the global variable.
|
|
func (v *GlobalValue) Load() llvm.Value {
|
|
return v.Underlying.Initializer()
|
|
}
|
|
|
|
// Store sets the initializer of the global variable.
|
|
func (v *GlobalValue) Store(value llvm.Value) {
|
|
if !value.IsConstant() {
|
|
v.MarkDirty()
|
|
v.Eval.builder.CreateStore(value, v.Underlying)
|
|
} else {
|
|
v.Underlying.SetInitializer(value)
|
|
}
|
|
}
|
|
|
|
// GetElementPtr returns a constant GEP on this global, which can be used in
|
|
// load and store instructions.
|
|
func (v *GlobalValue) GetElementPtr(indices []uint32) Value {
|
|
int32Type := v.Underlying.Type().Context().Int32Type()
|
|
gep := llvm.ConstGEP(v.Underlying, getLLVMIndices(int32Type, indices))
|
|
return &LocalValue{v.Eval, gep}
|
|
}
|
|
|
|
func (v *GlobalValue) String() string {
|
|
return "&GlobalValue{" + v.Underlying.Name() + "}"
|
|
}
|
|
|
|
// MarkDirty marks this global as dirty, meaning that every load from and store
|
|
// to this global (from now on) must be performed at runtime.
|
|
func (v *GlobalValue) MarkDirty() {
|
|
if !v.IsConstant() {
|
|
return // already dirty
|
|
}
|
|
v.Eval.dirtyGlobals[v.Underlying] = struct{}{}
|
|
}
|
|
|
|
// An alloca represents a local alloca, which is a stack allocated variable.
|
|
// It is emulated by storing the constant of the alloca.
|
|
type AllocaValue struct {
|
|
Eval *Eval
|
|
Underlying llvm.Value // the constant value itself if not dirty, otherwise the alloca instruction
|
|
Dirty bool // this value must be evaluated at runtime
|
|
}
|
|
|
|
// Value turns this alloca into a runtime alloca instead of a compile-time
|
|
// constant (if not already converted), and returns the alloca itself.
|
|
func (v *AllocaValue) Value() llvm.Value {
|
|
if !v.Dirty {
|
|
// Mark this alloca a dirty, meaning it is run at runtime instead of
|
|
// compile time.
|
|
alloca := v.Eval.builder.CreateAlloca(v.Underlying.Type(), "")
|
|
v.Eval.builder.CreateStore(v.Underlying, alloca)
|
|
v.Dirty = true
|
|
v.Underlying = alloca
|
|
}
|
|
return v.Underlying
|
|
}
|
|
|
|
// Type returns the type of this alloca, which is always a pointer.
|
|
func (v *AllocaValue) Type() llvm.Type {
|
|
if v.Dirty {
|
|
return v.Underlying.Type()
|
|
} else {
|
|
return llvm.PointerType(v.Underlying.Type(), 0)
|
|
}
|
|
}
|
|
|
|
func (v *AllocaValue) IsConstant() bool {
|
|
return !v.Dirty
|
|
}
|
|
|
|
// Load returns the value this alloca contains, which may be evaluated at
|
|
// runtime.
|
|
func (v *AllocaValue) Load() llvm.Value {
|
|
if v.Dirty {
|
|
ret := v.Eval.builder.CreateLoad(v.Underlying, "")
|
|
if ret.IsNil() {
|
|
panic("alloca is nil")
|
|
}
|
|
return ret
|
|
} else {
|
|
if v.Underlying.IsNil() {
|
|
panic("alloca is nil")
|
|
}
|
|
return v.Underlying
|
|
}
|
|
}
|
|
|
|
// Store updates the value of this alloca.
|
|
func (v *AllocaValue) Store(value llvm.Value) {
|
|
if v.Underlying.Type() != value.Type() {
|
|
panic("interp: trying to store to an alloca with a different type")
|
|
}
|
|
if v.Dirty || !value.IsConstant() {
|
|
v.Eval.builder.CreateStore(value, v.Value())
|
|
} else {
|
|
v.Underlying = value
|
|
}
|
|
}
|
|
|
|
// GetElementPtr returns a value (a *GetElementPtrValue) that keeps a reference
|
|
// to this alloca, so that Load() and Store() continue to work.
|
|
func (v *AllocaValue) GetElementPtr(indices []uint32) Value {
|
|
return &GetElementPtrValue{v, indices}
|
|
}
|
|
|
|
func (v *AllocaValue) String() string {
|
|
return "&AllocaValue{Type: " + v.Type().String() + "}"
|
|
}
|
|
|
|
// GetElementPtrValue wraps an alloca, keeping track of what the GEP points to
|
|
// so it can be used as a pointer value (with Load() and Store()).
|
|
type GetElementPtrValue struct {
|
|
Alloca *AllocaValue
|
|
Indices []uint32
|
|
}
|
|
|
|
// Type returns the type of this GEP, which is always of type pointer.
|
|
func (v *GetElementPtrValue) Type() llvm.Type {
|
|
if v.Alloca.Dirty {
|
|
return v.Value().Type()
|
|
} else {
|
|
return llvm.PointerType(v.Load().Type(), 0)
|
|
}
|
|
}
|
|
|
|
func (v *GetElementPtrValue) IsConstant() bool {
|
|
return v.Alloca.IsConstant()
|
|
}
|
|
|
|
// Value creates the LLVM GEP instruction of this GetElementPtrValue wrapper and
|
|
// returns it.
|
|
func (v *GetElementPtrValue) Value() llvm.Value {
|
|
if v.Alloca.Dirty {
|
|
alloca := v.Alloca.Value()
|
|
int32Type := v.Alloca.Type().Context().Int32Type()
|
|
llvmIndices := getLLVMIndices(int32Type, v.Indices)
|
|
return v.Alloca.Eval.builder.CreateGEP(alloca, llvmIndices, "")
|
|
} else {
|
|
panic("interp: todo: pointer to alloca gep")
|
|
}
|
|
}
|
|
|
|
// Load deferences the pointer this GEP points to. For a constant GEP, it
|
|
// extracts the value from the underlying alloca.
|
|
func (v *GetElementPtrValue) Load() llvm.Value {
|
|
if v.Alloca.Dirty {
|
|
gep := v.Value()
|
|
return v.Alloca.Eval.builder.CreateLoad(gep, "")
|
|
} else {
|
|
underlying := v.Alloca.Load()
|
|
indices := v.Indices
|
|
if indices[0] != 0 {
|
|
panic("invalid GEP")
|
|
}
|
|
return llvm.ConstExtractValue(underlying, indices[1:])
|
|
}
|
|
}
|
|
|
|
// Store stores to the pointer this GEP points to. For a constant GEP, it
|
|
// updates the underlying allloca.
|
|
func (v *GetElementPtrValue) Store(value llvm.Value) {
|
|
if v.Alloca.Dirty || !value.IsConstant() {
|
|
alloca := v.Alloca.Value()
|
|
int32Type := v.Alloca.Type().Context().Int32Type()
|
|
llvmIndices := getLLVMIndices(int32Type, v.Indices)
|
|
gep := v.Alloca.Eval.builder.CreateGEP(alloca, llvmIndices, "")
|
|
v.Alloca.Eval.builder.CreateStore(value, gep)
|
|
} else {
|
|
underlying := v.Alloca.Load()
|
|
indices := v.Indices
|
|
if indices[0] != 0 {
|
|
panic("invalid GEP")
|
|
}
|
|
underlying = llvm.ConstInsertValue(underlying, value, indices[1:])
|
|
v.Alloca.Store(underlying)
|
|
}
|
|
}
|
|
|
|
func (v *GetElementPtrValue) GetElementPtr(indices []uint32) Value {
|
|
if v.Alloca.Dirty {
|
|
panic("interp: todo: gep on a dirty gep")
|
|
} else {
|
|
combined := append([]uint32{}, v.Indices...)
|
|
combined[len(combined)-1] += indices[0]
|
|
combined = append(combined, indices[1:]...)
|
|
return &GetElementPtrValue{v.Alloca, combined}
|
|
}
|
|
}
|
|
|
|
func (v *GetElementPtrValue) String() string {
|
|
indices := ""
|
|
for _, n := range v.Indices {
|
|
if indices != "" {
|
|
indices += ", "
|
|
}
|
|
indices += strconv.Itoa(int(n))
|
|
}
|
|
return "&GetElementPtrValue{Alloca: " + v.Alloca.String() + ", Indices: [" + indices + "]}"
|
|
}
|
|
|
|
// PointerCastValue represents a bitcast operation on a pointer.
|
|
type PointerCastValue struct {
|
|
Eval *Eval
|
|
Underlying Value
|
|
CastType llvm.Type
|
|
}
|
|
|
|
// Value returns a constant bitcast value.
|
|
func (v *PointerCastValue) Value() llvm.Value {
|
|
from := v.Underlying.Value()
|
|
return llvm.ConstBitCast(from, v.CastType)
|
|
}
|
|
|
|
// Type returns the type this pointer has been cast to.
|
|
func (v *PointerCastValue) Type() llvm.Type {
|
|
return v.CastType
|
|
}
|
|
|
|
func (v *PointerCastValue) IsConstant() bool {
|
|
return v.Underlying.IsConstant()
|
|
}
|
|
|
|
// Load tries to load and bitcast the given value. If this value cannot be
|
|
// bitcasted, Load panics.
|
|
func (v *PointerCastValue) Load() llvm.Value {
|
|
if v.Underlying.IsConstant() {
|
|
typeFrom := v.Underlying.Type().ElementType()
|
|
typeTo := v.CastType.ElementType()
|
|
if isScalar(typeFrom) && isScalar(typeTo) && v.Eval.TargetData.TypeAllocSize(typeFrom) == v.Eval.TargetData.TypeAllocSize(typeTo) {
|
|
return llvm.ConstBitCast(v.Underlying.Load(), v.CastType.ElementType())
|
|
}
|
|
}
|
|
|
|
panic("interp: load from a pointer bitcast: " + v.String())
|
|
}
|
|
|
|
// Store panics: it is not (yet) possible to store directly to a bitcast.
|
|
func (v *PointerCastValue) Store(value llvm.Value) {
|
|
panic("interp: store on a pointer bitcast")
|
|
}
|
|
|
|
// GetElementPtr panics: it is not (yet) possible to do a GEP operation on a
|
|
// bitcast.
|
|
func (v *PointerCastValue) GetElementPtr(indices []uint32) Value {
|
|
panic("interp: GEP on a pointer bitcast")
|
|
}
|
|
|
|
func (v *PointerCastValue) String() string {
|
|
return "&PointerCastValue{Value: " + v.Underlying.String() + ", CastType: " + v.CastType.String() + "}"
|
|
}
|
|
|
|
// MapValue implements a Go map which is created at compile time and stored as a
|
|
// global variable.
|
|
type MapValue struct {
|
|
Eval *Eval
|
|
PkgName string
|
|
Underlying llvm.Value
|
|
Keys []Value
|
|
Values []Value
|
|
KeySize int
|
|
ValueSize int
|
|
KeyType llvm.Type
|
|
ValueType llvm.Type
|
|
}
|
|
|
|
func (v *MapValue) newBucket() llvm.Value {
|
|
ctx := v.Eval.Mod.Context()
|
|
i8ptrType := llvm.PointerType(ctx.Int8Type(), 0)
|
|
bucketType := ctx.StructType([]llvm.Type{
|
|
llvm.ArrayType(ctx.Int8Type(), 8), // tophash
|
|
i8ptrType, // next bucket
|
|
llvm.ArrayType(v.KeyType, 8), // key type
|
|
llvm.ArrayType(v.ValueType, 8), // value type
|
|
}, false)
|
|
bucketValue := getZeroValue(bucketType)
|
|
bucket := llvm.AddGlobal(v.Eval.Mod, bucketType, v.PkgName+"$mapbucket")
|
|
bucket.SetInitializer(bucketValue)
|
|
bucket.SetLinkage(llvm.InternalLinkage)
|
|
bucket.SetUnnamedAddr(true)
|
|
return bucket
|
|
}
|
|
|
|
// Value returns a global variable which is a pointer to the actual hashmap.
|
|
func (v *MapValue) Value() llvm.Value {
|
|
if !v.Underlying.IsNil() {
|
|
return v.Underlying
|
|
}
|
|
|
|
ctx := v.Eval.Mod.Context()
|
|
i8ptrType := llvm.PointerType(ctx.Int8Type(), 0)
|
|
|
|
var firstBucketGlobal llvm.Value
|
|
if len(v.Keys) == 0 {
|
|
// there are no buckets
|
|
firstBucketGlobal = llvm.ConstPointerNull(i8ptrType)
|
|
} else {
|
|
// create initial bucket
|
|
firstBucketGlobal = v.newBucket()
|
|
}
|
|
|
|
// Insert each key/value pair in the hashmap.
|
|
bucketGlobal := firstBucketGlobal
|
|
for i, key := range v.Keys {
|
|
var keyBuf []byte
|
|
llvmKey := key.Value()
|
|
llvmValue := v.Values[i].Value()
|
|
if key.Type().TypeKind() == llvm.StructTypeKind && key.Type().StructName() == "runtime._string" {
|
|
keyPtr := llvm.ConstExtractValue(llvmKey, []uint32{0})
|
|
keyLen := llvm.ConstExtractValue(llvmKey, []uint32{1})
|
|
keyPtrVal := v.Eval.getValue(keyPtr)
|
|
keyBuf = getStringBytes(keyPtrVal, keyLen)
|
|
} else if key.Type().TypeKind() == llvm.IntegerTypeKind {
|
|
keyBuf = make([]byte, v.Eval.TargetData.TypeAllocSize(key.Type()))
|
|
n := key.Value().ZExtValue()
|
|
for i := range keyBuf {
|
|
keyBuf[i] = byte(n)
|
|
n >>= 8
|
|
}
|
|
} else {
|
|
panic("interp: map key type not implemented: " + key.Type().String())
|
|
}
|
|
hash := v.hash(keyBuf)
|
|
|
|
if i%8 == 0 && i != 0 {
|
|
// Bucket is full, create a new one.
|
|
newBucketGlobal := v.newBucket()
|
|
zero := llvm.ConstInt(ctx.Int32Type(), 0, false)
|
|
newBucketPtr := llvm.ConstInBoundsGEP(newBucketGlobal, []llvm.Value{zero})
|
|
newBucketPtrCast := llvm.ConstBitCast(newBucketPtr, i8ptrType)
|
|
// insert pointer into old bucket
|
|
bucket := bucketGlobal.Initializer()
|
|
bucket = llvm.ConstInsertValue(bucket, newBucketPtrCast, []uint32{1})
|
|
bucketGlobal.SetInitializer(bucket)
|
|
// switch to next bucket
|
|
bucketGlobal = newBucketGlobal
|
|
}
|
|
|
|
tophashValue := llvm.ConstInt(ctx.Int8Type(), uint64(v.topHash(hash)), false)
|
|
bucket := bucketGlobal.Initializer()
|
|
bucket = llvm.ConstInsertValue(bucket, tophashValue, []uint32{0, uint32(i % 8)})
|
|
bucket = llvm.ConstInsertValue(bucket, llvmKey, []uint32{2, uint32(i % 8)})
|
|
bucket = llvm.ConstInsertValue(bucket, llvmValue, []uint32{3, uint32(i % 8)})
|
|
bucketGlobal.SetInitializer(bucket)
|
|
}
|
|
|
|
// Create the hashmap itself.
|
|
zero := llvm.ConstInt(ctx.Int32Type(), 0, false)
|
|
bucketPtr := llvm.ConstInBoundsGEP(firstBucketGlobal, []llvm.Value{zero})
|
|
hashmapType := v.Type()
|
|
hashmap := llvm.ConstNamedStruct(hashmapType, []llvm.Value{
|
|
llvm.ConstPointerNull(llvm.PointerType(hashmapType, 0)), // next
|
|
llvm.ConstBitCast(bucketPtr, i8ptrType), // buckets
|
|
llvm.ConstInt(hashmapType.StructElementTypes()[2], uint64(len(v.Keys)), false), // count
|
|
llvm.ConstInt(ctx.Int8Type(), uint64(v.KeySize), false), // keySize
|
|
llvm.ConstInt(ctx.Int8Type(), uint64(v.ValueSize), false), // valueSize
|
|
llvm.ConstInt(ctx.Int8Type(), 0, false), // bucketBits
|
|
})
|
|
|
|
// Create a pointer to this hashmap.
|
|
hashmapPtr := llvm.AddGlobal(v.Eval.Mod, hashmap.Type(), v.PkgName+"$map")
|
|
hashmapPtr.SetInitializer(hashmap)
|
|
hashmapPtr.SetLinkage(llvm.InternalLinkage)
|
|
hashmapPtr.SetUnnamedAddr(true)
|
|
v.Underlying = llvm.ConstInBoundsGEP(hashmapPtr, []llvm.Value{zero})
|
|
return v.Underlying
|
|
}
|
|
|
|
// Type returns type runtime.hashmap, which is the actual hashmap type.
|
|
func (v *MapValue) Type() llvm.Type {
|
|
return v.Eval.Mod.GetTypeByName("runtime.hashmap")
|
|
}
|
|
|
|
func (v *MapValue) IsConstant() bool {
|
|
return true // TODO: dirty maps
|
|
}
|
|
|
|
// Load panics: maps are of reference type so cannot be dereferenced.
|
|
func (v *MapValue) Load() llvm.Value {
|
|
panic("interp: load from a map")
|
|
}
|
|
|
|
// Store panics: maps are of reference type so cannot be stored to.
|
|
func (v *MapValue) Store(value llvm.Value) {
|
|
panic("interp: store on a map")
|
|
}
|
|
|
|
// GetElementPtr panics: maps are of reference type so their (interior)
|
|
// addresses cannot be calculated.
|
|
func (v *MapValue) GetElementPtr(indices []uint32) Value {
|
|
panic("interp: GEP on a map")
|
|
}
|
|
|
|
// PutString does a map assign operation, assuming that the map is of type
|
|
// map[string]T.
|
|
func (v *MapValue) PutString(keyBuf, keyLen, valPtr Value) {
|
|
if !v.Underlying.IsNil() {
|
|
panic("map already created")
|
|
}
|
|
|
|
var value llvm.Value
|
|
switch valPtr := valPtr.(type) {
|
|
case *PointerCastValue:
|
|
value = valPtr.Underlying.Load()
|
|
if v.ValueType.IsNil() {
|
|
v.ValueType = value.Type()
|
|
if int(v.Eval.TargetData.TypeAllocSize(v.ValueType)) != v.ValueSize {
|
|
panic("interp: map store value type has the wrong size")
|
|
}
|
|
} else {
|
|
if value.Type() != v.ValueType {
|
|
panic("interp: map store value type is inconsistent")
|
|
}
|
|
}
|
|
default:
|
|
panic("interp: todo: handle map value pointer")
|
|
}
|
|
|
|
keyType := v.Eval.Mod.GetTypeByName("runtime._string")
|
|
v.KeyType = keyType
|
|
key := getZeroValue(keyType)
|
|
key = llvm.ConstInsertValue(key, keyBuf.Value(), []uint32{0})
|
|
key = llvm.ConstInsertValue(key, keyLen.Value(), []uint32{1})
|
|
|
|
// TODO: avoid duplicate keys
|
|
v.Keys = append(v.Keys, &LocalValue{v.Eval, key})
|
|
v.Values = append(v.Values, &LocalValue{v.Eval, value})
|
|
}
|
|
|
|
// Get FNV-1a hash of this string.
|
|
//
|
|
// https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function#FNV-1a_hash
|
|
func (v *MapValue) hash(data []byte) uint32 {
|
|
var result uint32 = 2166136261 // FNV offset basis
|
|
for _, c := range data {
|
|
result ^= uint32(c)
|
|
result *= 16777619 // FNV prime
|
|
}
|
|
return result
|
|
}
|
|
|
|
// Get the topmost 8 bits of the hash, without using a special value (like 0).
|
|
func (v *MapValue) topHash(hash uint32) uint8 {
|
|
tophash := uint8(hash >> 24)
|
|
if tophash < 1 {
|
|
// 0 means empty slot, so make it bigger.
|
|
tophash += 1
|
|
}
|
|
return tophash
|
|
}
|
|
|
|
func (v *MapValue) String() string {
|
|
return "&MapValue{KeySize: " + strconv.Itoa(v.KeySize) + ", ValueSize: " + strconv.Itoa(v.ValueSize) + "}"
|
|
}
|