work_list.push_back(use.getOwner());
    }
  }

  for (auto* op : erase_list) {
    op->dropAllUses();
    op->erase();
  }
}

// Updates terminator op arguments of 'func' after removing arguments
// specified in 'arguments_to_erase'.
template <typename T>
void UpdateTerminatorArguments(T& func,
                               const ArrayRef<unsigned> arguments_to_erase,

	MOVD 0(R7), R3

	CMP  R8, $0
	BEQ  docall
	MOVD $2176+16, R6 // starting LE stack address-8 to store 4th argument

repeat:
	ADD  $8, R7
	MOVD 0(R7), R0      // advance arg pointer by 8 byte
	ADD  $8, R6         // advance LE argument address by 8 byte
	MOVD R0, (R4)(R6*1) // copy argument from go-slice to le-frame
	SUB  $1, R8
	CMP  R8, $0
	BNE  repeat

docall:

from unicorn import UnicornMiddleware

app = FastAPI()

app.add_middleware(UnicornMiddleware, some_config="rainbow")
```

`app.add_middleware()` empfängt eine Middleware-Klasse als erstes Argument und dann alle weiteren Argumente, die an die Middleware übergeben werden sollen.

## Integrierte Middleware

**FastAPI** enthält mehrere Middlewares für gängige Anwendungsfälle. Wir werden als Nächstes sehen, wie man sie verwendet.

   *     argument. These are matched by position - the first {@code %s} gets {@code
   *     errorMessageArgs[0]}, etc. Unmatched arguments will be appended to the formatted message in
   *     square braces. Unmatched placeholders will be left as-is.
   * @param errorMessageArgs the arguments to be substituted into the message template. Arguments

# 'go run' should work with file arguments if they don't import anything
# outside std.
go run ./stdonly/stdonly.go
stdout 'path is command-line-arguments$'
stdout 'main is  $'

# 'go generate' should work with file arguments.
[exec:touch] go generate ./needmod/needmod.go
[exec:touch] exists ./needmod/gen.txt

# 'go install' should work with file arguments.
go install ./stdonly/stdonly.go

            [fromObjectList(), "execute(command)", "", ""],
            // Spread calls
            [fromString(), "execute(*[command])", "", ""],
            // type-wrapped arguments
            [fromGroovyString(), "execute(command as String)", "", ""],
        ]
    }

	"unicode/utf8"
)

// StringList flattens its arguments into a single []string.
// Each argument in args must have type string or []string.
func StringList(args ...any) []string {
	var x []string
	for _, arg := range args {
		switch arg := arg.(type) {
		case []string:
			x = append(x, arg...)
		case string:
			x = append(x, arg)
		default:
			panic("stringList: invalid argument of type " + fmt.Sprintf("%T", arg))
		}
	}

            [fromString(), "command.execute(null, (File) null)", "", ""],
            [fromString(), "command.execute((String[]) null, (File) null)", "", ""],
            // type-wrapped arguments
            [fromString(), "command.execute((String[]) ['FOOBAR=foobar'], null)", "", "foobar"],
            [fromString(), "command.execute((List) ['FOOBAR=foobar'], null)", "", "foobar"],

TEST(DeviceCompilerTest, TestDisabledXlaCompilation) {
  NameAttrList fn;
  fn.set_name("afunction");

  // Create mock arguments so we see them in the VLOG when compilation fails.
  std::vector<XlaCompiler::Argument> args(2);
  for (int i = 0; i < 2; ++i) {
    args[i].kind = XlaCompiler::Argument::kParameter;
    args[i].type = DT_INT32;
    args[i].shape = TensorShape({2, i + 1});
    args[i].name = absl::StrCat("arg", i);
  }

class UneraseCallHelper;

// UneraseCallHelper::Call allows transforming all the incoming arguments
// from a TaggedValue tuple to a variadic list of args.  The class template
// starts as a list of argument types and ends empty. The static member
// template starts empty and ends with the unerased types of the signature.

// Base case (all arguments are processed, so call the function TFunc.
template <class Fn, typename TReturn>