return 1;
  }
  return 0;
}

// Tests libgo.so to export the following functions.
//   int8_t DidInitRun() // returns true
//   int8_t DidMainRun() // returns true
//   int32_t FromPkg() // returns 1024
int main(int argc, char** argv) {
  void* handle = dlopen(argv[1], RTLD_LAZY | RTLD_GLOBAL);
  if (!handle) {
    fprintf(stderr, "ERROR: failed to open the shared library: %s\n",
		    dlerror());
    return 2;
  }

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

//go:noinline
func f(x *byte, m map[string]*bool) {
	if err := g(x, *m["hello"]); err != nil { // this was miscompiled
		return
	}
}

func main2() {
	m := make(map[string]*bool)
	x := false
	m["hello"] = &x
	b := byte(17)
	f(&b, m)
}

func main() {
	main2()
	main1()

			if x&0xff00 != y&0xff00 {
				t.Errorf("x=%x y=%x\n", x, y)
				done <- false
				return
			}
		}
		done <- true
	}()
	<-done
	<-done
}

func TestDupLoad(t *testing.T) {
	main1(t)
	main2(t)

      }
    }
  }
  experimental_debug_info {
  }
}
node {
  name: "main"
  op: "_Retval"
  input: "StatefulIf"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "index"
    value {
      i: 0
    }
  }
}
node {
  name: "main1"
  op: "_Retval"
  input: "StatelessIf"
  attr {
    key: "T"
    value {

      }
    }
  }
  experimental_debug_info {
  }
}
node {
  name: "main"
  op: "_Retval"
  input: "StatefulWhile:1"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "index"
    value {
      i: 0
    }
  }
}
node {
  name: "main1"
  op: "_Retval"
  input: "StatelessWhile:1"
  attr {
    key: "T"
    value {

      }
    }
  }
  experimental_debug_info {
  }
}
node {
  name: "main"
  op: "_Retval"
  input: "StatefulIf"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "index"
    value {
      i: 0
    }
  }
}
node {
  name: "main1"
  op: "_Retval"
  input: "StatelessIf"
  attr {
    key: "T"
    value {

	if GOOS == "darwin" || GOOS == "ios" {
		linkFlags = ""
	}

	runCC(t, "-o", cmd, "main2.c", linkFlags, libname)

	defer os.Remove(libname)
	defer os.Remove(bin)

	out := runExe(t, []string{"LD_LIBRARY_PATH=."}, bin)

	if strings.TrimSpace(out) != "PASS" {
		t.Error(out)
	}
}

// test3: tests main.main is exported on android.
func TestMainExportedOnAndroid(t *testing.T) {
	globalSkip(t)

	tg.tempFile("src/main1/main.go", "package main\nimport _ \"p2\"\nfunc main() {}\n")

	tg.run("list", "-f={{.Target}}", "p1")
	p1 := strings.TrimSpace(tg.getStdout())
	tg.run("list", "-f={{.Target}}", "p2")
	p2 := strings.TrimSpace(tg.getStdout())
	tg.run("list", "-f={{.Target}}", "main1")
	main1 := strings.TrimSpace(tg.getStdout())

	tg.run("install", "main1")

	tg.mustExist(main1)

		ccArgs = append(cc, "-o", exe, "-nopie", "main5.c", "libgo2.a")
		out, err = exec.Command(ccArgs[0], ccArgs[1:]...).CombinedOutput()
		t.Logf("%v\n%s", ccArgs, out)
	}

	// Don't use either -no-pie or -nopie
	if err != nil && bytes.Contains(out, []byte("unrecognized")) {
		ccArgs = append(cc, "-o", exe, "main5.c", "libgo2.a")
		out, err = exec.Command(ccArgs[0], ccArgs[1:]...).CombinedOutput()