• Russ Cox's avatar
    cmd/compile: recognize Syscall-like functions for liveness analysis · 1ac637c7
    Russ Cox authored
    Consider this code:
    
    	func f(*int)
    
    	func g() {
    		p := new(int)
    		f(p)
    	}
    
    where f is an assembly function.
    In general liveness analysis assumes that during the call to f, p is dead
    in this frame. If f has retained p, p will be found alive in f's frame and keep
    the new(int) from being garbage collected. This is all correct and works.
    We use the Go func declaration for f to give the assembly function
    liveness information (the arguments are assumed live for the entire call).
    
    Now consider this code:
    
    	func h1() {
    		p := new(int)
    		syscall.Syscall(1, 2, 3, uintptr(unsafe.Pointer(p)))
    	}
    
    Here syscall.Syscall is taking the place of f, but because its arguments
    are uintptr, the liveness analysis and the garbage collector ignore them.
    Since p is no longer live in h once the call starts, if the garbage collector
    scans the stack while the system call is blocked, it will find no reference
    to the new(int) and reclaim it. If the kernel is going to write to *p once
    the call finishes, reclaiming the memory is a mistake.
    
    We can't change the arguments or the liveness information for
    syscall.Syscall itself, both for compatibility and because sometimes the
    arguments really are integers, and the garbage collector will get quite upset
    if it finds an integer where it expects a pointer. The problem is that
    these arguments are fundamentally untyped.
    
    The solution we have taken in the syscall package's wrappers in past
    releases is to insert a call to a dummy function named "use", to make
    it look like the argument is live during the call to syscall.Syscall:
    
    	func h2() {
    		p := new(int)
    		syscall.Syscall(1, 2, 3, uintptr(unsafe.Pointer(p)))
    		use(unsafe.Pointer(p))
    	}
    
    Keeping p alive during the call means that if the garbage collector
    scans the stack during the system call now, it will find the reference to p.
    
    Unfortunately, this approach is not available to users outside syscall,
    because 'use' is unexported, and people also have to realize they need
    to use it and do so. There is much existing code using syscall.Syscall
    without a 'use'-like function. That code will fail very occasionally in
    mysterious ways (see #13372).
    
    This CL fixes all that existing code by making the compiler do the right
    thing automatically, without any code modifications. That is, it takes h1
    above, which is incorrect code today, and makes it correct code.
    
    Specifically, if the compiler sees a foreign func definition (one
    without a body) that has uintptr arguments, it marks those arguments
    as "unsafe uintptrs". If it later sees the function being called
    with uintptr(unsafe.Pointer(x)) as an argument, it arranges to mark x
    as having escaped, and it makes sure to hold x in a live temporary
    variable until the call returns, so that the garbage collector cannot
    reclaim whatever heap memory x points to.
    
    For now I am leaving the explicit calls to use in package syscall,
    but they can be removed early in a future cycle (likely Go 1.7).
    
    The rule has no effect on escape analysis, only on liveness analysis.
    
    Fixes #13372.
    
    Change-Id: I2addb83f70d08db08c64d394f9d06ff0a063c500
    Reviewed-on: https://go-review.googlesource.com/18584Reviewed-by: 's avatarIan Lance Taylor <iant@golang.org>
    1ac637c7
prog.go 6.61 KB