// the relocation phase.
				// Therefore, all packages are merged under a fake .FILE
				// "go_functions".
				// TODO(aix); remove once ld has been fixed or the triggering
				// relocation has been found and fixed.
				if currSymSrcFile.name == "" {
					currSymSrcFile.name = ldr.SymPkg(x)
					f.writeSymbolNewFile(ctxt, "go_functions", uint64(ldr.SymValue(x)), xfile.getXCOFFscnum(ldr.SymSect(x)))
				}
			}

		}
	}

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import "C"

var sink []byte

//export GoFunction7
func GoFunction7() {
	sink = make([]byte, 4096)
}

func main() {

)

var started int32

// Start a goroutine that loops forever.
func init() {
	runtime.GOMAXPROCS(1)
	go func() {
		for {
			atomic.StoreInt32(&started, 1)
		}
	}()
}

//export GoFunction8
func GoFunction8() {
	for atomic.LoadInt32(&started) == 0 {
		runtime.Gosched()
	}
	os.Exit(0)
}

func main() {

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test preemption.

#include <stdlib.h>

#include "libgo8.h"

int main() {
	GoFunction8();

	// That should have exited the program.
	abort();

// license that can be found in the LICENSE file.

// Test that lots of calls don't deadlock.

#include <stdio.h>

#include "libgo7.h"

int main() {
	int i;

	for (i = 0; i < 100000; i++) {
		GoFunction7();
	}
	return 0;

                             ConcreteFunction** function) = 0;

  // Retrieve a list of child functions from a SavedModel given a starting node.
  // 0 is the root node.
  virtual Status GetFunctions(
      int node_id,
      absl::flat_hash_map<std::string, ConcreteFunction*>* functions) = 0;

  // Retrieve a SignatureDefFunction from a SavedModel, using the key of the
  // SignatureDef map:

class TFSavedModelAPI : public SavedModelAPI {
 public:
  Status GetFunction(const std::string& function_path,
                     ConcreteFunction** function) override;

  Status GetFunctions(
      int node_id,
      absl::flat_hash_map<std::string, ConcreteFunction*>* functions) override;

  Status GetSignatureDefFunction(const std::string& signature_def_key,

  if (*function == nullptr) {
    return errors::NotFound("No function found at path ", function_path);
  }

  return Status();
}

Status TFSavedModelAPI::GetFunctions(
    int node_id,
    absl::flat_hash_map<std::string, ConcreteFunction*>* functions) {
  const auto& nodes = bundle_.saved_object_graph().nodes();
  if (node_id >= nodes.size()) {
    return errors::OutOfRange(

                                                const TF_Function* grad,
                                                TF_Status* status);

// Returns the number of TF_Functions registered in `g`.
TF_CAPI_EXPORT extern int TF_GraphNumFunctions(TF_Graph* g);

// Fills in `funcs` with the TF_Function* registered in `g`.
// `funcs` must point to an array of TF_Function* of length at least

                // Collect constructors
                findAvailableConstructors(scope, name).mapTo(this) { AvailableSymbol(it, importKind) }

                // Collect functions
                scope.getFunctions(name).mapTo(this) { AvailableSymbol(it, importKind) }
            }
        }
    }

    fun findPropertiesInScopes(scopes: List<FirScope>, name: Name): List<AvailableSymbol<FirVariableSymbol<*>>> {