code: func (b *builder) cond(fn *Function, e ast.Expr, t, f *BasicBlock) {
  	switch e := e.(type) {
  	case *ast.ParenExpr:
  		b.cond(fn, e.X, t, f)
  		return
  
  	case *ast.BinaryExpr:
  		switch e.Op {
  		case token.LAND:
  			ltrue := fn.newBasicBlock("cond.true")
  			b.cond(fn, e.X, ltrue, f)
  			fn.currentBlock = ltrue
  			b.cond(fn, e.Y, t, f)
  			return
  
  		case token.LOR:
  			lfalse := fn.newBasicBlock("cond.false")
  			b.cond(fn, e.X, t, lfalse)
  			fn.currentBlock = lfalse
  			b.cond(fn, e.Y, t, f)
  			return
  		}
  
  	case *ast.UnaryExpr:
  		if e.Op == token.NOT {
  			b.cond(fn, e.X, f, t)
  			return
  		}
  	}
  
  	// A traditional compiler would simplify "if false" (etc) here
  	// but we do not, for better fidelity to the source code.
  	//
  	// The value of a constant condition may be platform-specific,
  	// and may cause blocks that are reachable in some configuration
  	// to be hidden from subsequent analyses such as bug-finding tools.
  	emitIf(fn, b.expr(fn, e), t, f)
  }
docs: // cond emits to fn code to evaluate boolean condition e and jump
  // to t or f depending on its value, performing various simplifications.
  //
  // Postcondition: fn.currentBlock is nil.
  //