Lines Matching refs:Left
39 ln.Name.Defn.Left.Name.SetUsed(true)
48 if defn.Left.Name.Used() {
51 yyerrorl(defn.Left.Pos, "%v declared and not used", ln.Sym)
52 defn.Left.Name.SetUsed(true) // suppress repeats
114 callfunc := n.Left
119 lhs := arg.Left
138 // n.Left = walkstmt(n.Left)
199 n.Left = walkexpr(n.Left, &init)
200 n = mkcall1(chanfn("chanrecv1", 2, n.Left.Type), nil, &init, n.Left, nodnil())
218 v := n.Left
245 switch n.Left.Op {
247 n.Left = walkprintfunc(n.Left, &n.Ninit)
250 n.Left = copyany(n.Left, &n.Ninit, true)
253 n.Left = walkexpr(n.Left, &n.Ninit)
260 if n.Left != nil {
261 walkstmtlist(n.Left.Ninit.Slice())
262 init := n.Left.Ninit
263 n.Left.Ninit.Set(nil)
264 n.Left = walkexpr(n.Left, &init)
265 n.Left = addinit(n.Left, init.Slice())
272 n.Left = walkexpr(n.Left, &n.Ninit)
277 switch n.Left.Op {
279 n.Left = walkprintfunc(n.Left, &n.Ninit)
282 n.Left = copyany(n.Left, &n.Ninit, true)
285 n.Left = walkexpr(n.Left, &n.Ninit)
361 l := n.Left
448 // n.Left = walkexpr(n.Left, init)
489 nn.Left.SetNonNil(true)
509 n.Left = walkexpr(n.Left, init)
512 n.Left = walkexpr(n.Left, init)
517 n.Left = walkexpr(n.Left, init)
520 n.Left = walkexpr(n.Left, init)
524 n.Right.Right = typename(n.Left.Type)
526 if !n.Type.IsInterface() && !n.Left.Type.IsEmptyInterface() {
527 n.List.Set1(itabname(n.Type, n.Left.Type))
532 if n.Op == ODOTPTR && n.Left.Type.Elem().Width == 0 {
534 n.Left = cheapexpr(n.Left, init)
536 checknil(n.Left, init)
539 n.Left = walkexpr(n.Left, init)
542 n.Left = walkexpr(n.Left, init)
546 t := n.Left.Type
552 safeexpr(n.Left, init)
558 n.Left = walkexpr(n.Left, init)
560 t := n.Left.Type
568 if n.Left == nil && n.Right == nil {
569 n.Left = n.List.First()
572 n.Left = walkexpr(n.Left, init)
576 n.Left = walkexpr(n.Left, init)
590 n.Left = walkexpr(n.Left, init)
593 // because they cannot run before n.Left is checked.
606 n = mkcall("gopanic", nil, init, n.Left)
616 t := n.Left.Type
620 n.Left = walkexpr(n.Left, init)
626 if n.Left.Op == OCLOSURE {
631 n.List.Prepend(n.Left.Func.Enter.Slice()...)
633 n.Left.Func.Enter.Set(nil)
636 n.Left = n.Left.Func.Closure.Func.Nname
640 if n.Left.Type.NumResults() == 1 {
641 n.Type = n.Left.Type.Results().Field(0).Type
643 n.Type = n.Left.Type.Results()
647 t := n.Left.Type
652 n.Left = walkexpr(n.Left, init)
659 t := n.Left.Type
663 n.Left = walkexpr(n.Left, init)
665 ll := ascompatte(n, false, t.Recvs(), []*Node{n.Left.Left}, 0, init)
668 n.Left.Left = nil
669 updateHasCall(n.Left)
675 n.Left = walkexpr(n.Left, init)
676 n.Left = safeexpr(n.Left, init)
696 // x = <-c; n.Left is x, n.Right.Left is c.
698 n.Right.Left = walkexpr(n.Right.Left, init)
700 n1 := nod(OADDR, n.Left, nil)
701 r := n.Right.Left // the channel
719 // Left in place for back end.
722 r.Left = typename(r.Type.Elem())
729 if n.Left != nil && n.Right != nil {
765 r.Left = walkexpr(r.Left, init)
773 fn := chanfn("chanrecv2", 2, r.Left.Type)
775 call := mkcall1(fn, ok.Type, init, r.Left, n1)
785 r.Left = walkexpr(r.Left, init)
787 t := r.Left.Type
809 r = mkcall1(fn, fn.Type.Results(), init, typename(t), r.Left, key)
813 r = mkcall1(fn, fn.Type.Results(), init, typename(t), r.Left, key, z)
859 n.Left = walkexpr(n.Left, init)
862 if isdirectiface(n.Left.Type) {
865 t = typename(n.Left.Type)
867 t = itabname(n.Left.Type, n.Type)
869 l := nod(OEFACE, t, n.Left)
886 // by using an existing addressable value identical to n.Left
890 case n.Left.Type.Size() == 0:
891 // n.Left is zero-sized. Use zerobase.
892 cheapexpr(n.Left, init) // Evaluate n.Left for side-effects. See issue 19246.
894 case n.Left.Type.IsBoolean() || (n.Left.Type.Size() == 1 && n.Left.Type.IsInteger()):
895 // n.Left is a bool/byte. Use staticbytes[n.Left].
896 n.Left = cheapexpr(n.Left, init)
897 value = nod(OINDEX, staticbytes, byteindex(n.Left))
899 case n.Left.Class() == PEXTERN && n.Left.Name != nil && n.Left.Name.Readonly():
900 // n.Left is a readonly global; use it directly.
901 value = n.Left
902 case !n.Left.Type.IsInterface() && n.Esc == EscNone && n.Left.Type.Width <= 1024:
903 // n.Left does not escape. Use a stack temporary initialized to n.Left.
904 value = temp(n.Left.Type)
905 init.Append(typecheck(nod(OAS, value, n.Left), Etop))
909 // Value is identical to n.Left.
913 t = typename(n.Left.Type)
915 t = itabname(n.Left.Type, n.Type)
930 if n.Type.IsEmptyInterface() && n.Left.Type.IsInterface() && !n.Left.Type.IsEmptyInterface() {
932 c := temp(n.Left.Type)
933 init.Append(nod(OAS, c, n.Left))
954 if !n.Left.Type.IsInterface() {
955 ll = append(ll, typename(n.Left.Type))
958 if n.Left.Type.IsInterface() {
961 ll = append(ll, itabname(n.Left.Type, n.Type))
965 if n.Left.Type.IsInterface() {
966 ll = append(ll, n.Left)
969 // orderexpr arranged for n.Left to be a temporary for all
974 if islvalue(n.Left) {
975 ll = append(ll, nod(OADDR, n.Left, nil))
977 ll = append(ll, nod(OADDR, copyexpr(n.Left, n.Left.Type, init), nil))
979 dowidth(n.Left.Type)
982 fn := syslook(convFuncName(n.Left.Type, n.Type))
983 fn = substArgTypes(fn, n.Left.Type, n.Type)
997 if n.Left.Type.IsFloat() {
1000 n = mkcall("float64toint64", n.Type, init, conv(n.Left, types.Types[TFLOAT64]))
1003 n = mkcall("float64touint64", n.Type, init, conv(n.Left, types.Types[TFLOAT64]))
1009 switch n.Left.Type.Etype {
1011 n = conv(mkcall("int64tofloat64", types.Types[TFLOAT64], init, conv(n.Left, types.Types[TINT64])), n.Type)
1014 n = conv(mkcall("uint64tofloat64", types.Types[TFLOAT64], init, conv(n.Left, types.Types[TUINT64])), n.Type)
1020 if n.Left.Type.IsFloat() {
1023 n = mkcall("float64toint64", n.Type, init, conv(n.Left, types.Types[TFLOAT64]))
1026 n = mkcall("float64touint64", n.Type, init, conv(n.Left, types.Types[TFLOAT64]))
1029 n = mkcall("float64touint32", n.Type, init, conv(n.Left, types.Types[TFLOAT64]))
1034 switch n.Left.Type.Etype {
1036 n = conv(mkcall("int64tofloat64", types.Types[TFLOAT64], init, conv(n.Left, types.Types[TINT64])), n.Type)
1039 n = conv(mkcall("uint64tofloat64", types.Types[TFLOAT64], init, conv(n.Left, types.Types[TUINT64])), n.Type)
1042 n = conv(mkcall("uint32tofloat64", types.Types[TFLOAT64], init, conv(n.Left, types.Types[TUINT32])), n.Type)
1049 n.Left = walkexpr(n.Left, init)
1052 n.Left = walkexpr(n.Left, init)
1059 n.Left = walkexpr(n.Left, init)
1063 et := n.Left.Type.Etype
1067 n = mkcall("complex128div", types.Types[TCOMPLEX128], init, conv(n.Left, types.Types[TCOMPLEX128]), conv(n.Right, types.Types[TCOMPLEX128]))
1111 n = mkcall(fn, n.Type, init, conv(n.Left, types.Types[et]), conv(n.Right, types.Types[et]))
1115 n.Left = walkexpr(n.Left, init)
1128 t := n.Left.Type
1140 } else if Isconst(n.Left, CTSTR) {
1141 n.SetBounded(bounded(r, int64(len(n.Left.Val().U.(string)))))
1158 n.Left = walkexpr(n.Left, init)
1160 map_ := n.Left
1164 // This m[k] expression is on the left-hand side of an assignment.
1198 n.Left = walkexpr(n.Left, init)
1209 if max != nil && max.Op == OCAP && samesafeexpr(n.Left, max.Left) {
1231 r = nod(OADDR, r.Left, nil)
1240 if (Op(n.Etype) == OEQ || Op(n.Etype) == ONE) && Isconst(n.Right, CTSTR) && n.Left.Op == OADDSTR && n.Left.List.Len() == 2 && Isconst(n.Left.List.Second(), CTSTR) && strlit(n.Right) == strlit(n.Left.List.Second()) {
1242 r := nod(Op(n.Etype), nod(OLEN, n.Left.List.First(), nil), nodintconst(0))
1253 case Isconst(n.Left, CTSTR) && Isconst(n.Right, CTSTR):
1255 case Isconst(n.Left, CTSTR):
1256 cs = n.Left
1260 ncs = n.Left
1358 n.Left = cheapexpr(n.Left, init)
1361 lstr := conv(n.Left, types.Types[TSTRING])
1376 // len(left) == len(right) && memequal(left, right, len)
1379 // len(left) != len(right) || !memequal(left, right, len)
1388 r = mkcall("cmpstring", types.Types[TINT], init, conv(n.Left, types.Types[TSTRING]), conv(n.Right, types.Types[TSTRING]))
1414 fn = substArgTypes(fn, n.Left.Type)
1415 n = mkcall1(fn, nil, init, n.Left)
1420 size := n.Left
1437 hint := n.Left
1534 l := n.Left
1595 n = mkcall("intstring", n.Type, init, a, conv(n.Left, types.Types[TINT64]))
1607 n = mkcall("slicebytetostring", n.Type, init, a, n.Left)
1611 n.Left = walkexpr(n.Left, init)
1619 n = mkcall("slicebytetostringtmp", n.Type, init, n.Left)
1632 n = mkcall("slicerunetostring", n.Type, init, a, n.Left)
1645 n = mkcall("stringtoslicebyte", n.Type, init, a, conv(n.Left, types.Types[TSTRING]))
1655 n.Left = walkexpr(n.Left, init)
1668 n = mkcall("stringtoslicerune", n.Type, init, a, n.Left)
1672 if !eqtype(n.Left.Type, n.Right.Type) {
1673 Fatalf("ifaceeq %v %v %v", n.Op, n.Left.Type, n.Right.Type)
1676 if n.Left.Type.IsEmptyInterface() {
1683 n.Left = cheapexpr(n.Left, init)
1684 lt := nod(OITAB, n.Left, nil)
1686 ld := nod(OIDATA, n.Left, nil)
1725 n1 = assignconv(n1, n.Left.Type.Elem(), "chan send")
1728 n = mkcall1(chanfn("chansend1", 2, n.Left.Type), nil, init, n.Left, n1)
1769 if high != nil && high.Op == OLEN && samesafeexpr(n.Left, high.Left) {
1779 return n.Left
2245 tsym = l.Left.Type.Sym
2247 tsym = l.Left.Type.Elem().Sym
2266 if n.Left == nil || n.Right == nil {
2270 lt := n.Left.Type
2276 if isblank(n.Left) {
2336 n.Right = a.Left
2361 l := n.Left
2363 // Save subexpressions needed on left side.
2367 l = l.Left
2371 if l.Op == OINDEX && l.Left.Type.IsArray() {
2373 l = l.Left
2388 l.Left = reorder3save(l.Left, all, i, &early)
2395 l.Left = reorder3save(l.Left, all, i, &early)
2411 // n.Left = reorder3save(n.Left, all, i, early)
2421 return q.Left
2432 n = n.Left
2435 if n.Left.Type != nil && n.Left.Type.IsArray() {
2436 n = n.Left
2455 n = n.Left
2466 a := outervalue(an.Left)
2469 a = a.Left
2559 return varexpr(n.Left) && varexpr(n.Right)
2576 // match each right given left
2584 if vmatch2(l, r.Left) {
2601 // isolate all left sides
2625 if vmatch1(l.Left, r) {
2962 nif.Left = nod(OGT, nod(OCONV, nn, nil), nod(OCONV, nod(OCAP, s, nil), nil))
2963 nif.Left.Left.Type = types.Types[TUINT]
2964 nif.Left.Right.Type = types.Types[TUINT]
3088 // General case, with no function calls left as arguments.
3101 nx.Left = nod(OLT, nod(OSUB, nod(OCAP, ns, nil), nod(OLEN, ns, nil)), na)
3148 if n.Left.Type.Elem().HasHeapPointer() {
3150 fn := writebarrierfn("typedslicecopy", n.Left.Type, n.Right.Type)
3151 return mkcall1(fn, n.Type, init, typename(n.Left.Type.Elem()), n.Left, n.Right)
3157 fn = substArgTypes(fn, n.Left.Type, n.Right.Type)
3158 return mkcall1(fn, n.Type, init, n.Left, n.Right)
3162 fn = substArgTypes(fn, n.Left.Type, n.Right.Type)
3163 return mkcall1(fn, n.Type, init, n.Left, n.Right, nodintconst(n.Left.Type.Elem().Width))
3166 n.Left = walkexpr(n.Left, init)
3168 nl := temp(n.Left.Type)
3171 l = append(l, nod(OAS, nl, n.Left))
3185 nif.Left = nod(OGT, nlen, nod(OLEN, nr, nil))
3231 // n.Left = walkcompare(n.Left, init)
3238 if n.Left.Type.IsInterface() && !n.Right.Type.IsInterface() {
3239 l = n.Left
3241 } else if !n.Left.Type.IsInterface() && n.Right.Type.IsInterface() {
3243 r = n.Left
3284 t := n.Left.Type
3309 cmpl := n.Left
3311 cmpl = cmpl.Left
3315 cmpr = cmpr.Left
3453 // n.Left = finishcompare(n.Left, x, r, init)
3476 return n.Left.Type.IsInteger() && n.Right.Type.IsInteger()
3482 // n.Left = walkinrange(n.Left)
3489 l := n.Left
3496 // Input is: l.Left l.Op l.Right ANDAND/OROR r.Left r.Op r.Right
3498 a, opl, b := l.Left, l.Op, l.Right
3499 x, opr, c := r.Left, r.Op, r.Right
3617 if smallintconst(n.Left) {
3618 v = n.Left.Int64()
3663 t := n.Left.Type
3722 t := n.Left.Type
3728 Fatalf("usefield %v %v without paramfld", n.Left.Type, n.Sym)
3734 outer := n.Left.Type
3839 if Isconst(n.Left, CTINT) && n.Left.Val().U.(*Mpint).CmpInt64(0) == 0 {
3849 if !candiscard(n.Left) || !candiscard(n.Right) || !candiscardlist(n.Ninit) || !candiscardlist(n.Nbody) || !candiscardlist(n.List) || !candiscardlist(n.Rlist) {
3867 // n.Left = walkprintfunc(n.Left, init)
3880 printargs = append(printargs, a.Left)
3905 a.Left = fn.Func.Nname
3916 // n.Left = substArgTypes(n.Left, t1, t2)
