Type argType = paramTypes.get(typeVar);
                    _ILOAD_OF(argType, stackVar);
                    stackVar += argType.getSize();
                }
                _INVOKESPECIAL(superclassType, "<init>", superMethodDescriptor);

                if (addNameParameter) {
                    // this.name = name
                    _ALOAD(0);

  // check if Flatbuffer builder can no longer hold the given amount of the data
  inline bool IsModelBiggerThan2GB(const uint64_t data_size) {
    return data_size > flatbuffer_size_max - builder_.GetSize();
  }

  // helper function for build stablehlo operators
  std::optional<BufferOffset<tflite::Operator>>
  BuildStablehloOperatorwithoutOptions(Operation* inst,

  if (begin_ty && begin_ty.getRank() != 1) {
    return op.emitOpError() << "requires begin operand to be 1D tensor";
  }

  RankedTensorType size_ty = GetRankedTensorTypeForOperand(op.getSize());
  if (size_ty && size_ty.getRank() != 1) {
    return op.emitOpError() << "requires size operand to be 1D tensor";
  }

  if (!begin_ty || !size_ty || !begin_ty.hasStaticShape() ||

mlir::LogicalResult SliceOp::verify() {
  SliceOp op = *this;
  auto input_type = op.getInput().getType().cast<ShapedType>();
  auto begin_type = op.getBegin().getType().cast<ShapedType>();
  auto size_type = op.getSize().getType().cast<ShapedType>();
  if (input_type.hasStaticShape() && begin_type.hasStaticShape() &&
      size_type.hasStaticShape()) {
    if (input_type.getRank() != begin_type.getNumElements()) {

private java.util.ArrayList pooledObjects; private boolean shuttingDown; public void SweeperPool(int, int, int, int, int); private int saneConvert(int); public synchronized Object get(); public synchronized boolean put(Object); public synchronized int getSize(); public synchronized void dispose(); public synchronized void trim(); public void objectDisposed(Object); public void objectAdded(Object); public void objectRetrieved(Object); } org/codehaus/plexus/util/TypeFormat.class package org.codehaus.plexus.util;...

	sdata.SetLocal(true)
	sdata.SetType(sym.SRODATA)
	sdata.SetSize(int64(len(str)))
	sdata.SetData([]byte(str))
	s.AddAddr(ctxt.Arch, sdata.Sym())
	s.AddUint(ctxt.Arch, uint64(len(str)))
}

func addinitarrdata(ctxt *Link, ldr *loader.Loader, s loader.Sym) {
	p := ldr.SymName(s) + ".ptr"
	sp := ldr.CreateSymForUpdate(p, 0)
	sp.SetType(sym.SINITARR)
	sp.SetSize(0)
	sp.SetDuplicateOK(true)
	sp.AddAddr(ctxt.Arch, s)

		*valueRegs = methodRegs
	}
	if retSize := methodFrameType.Size() - methodABI.retOffset; retSize > 0 {
		valueRet := add(valueFrame, valueABI.retOffset, "valueFrame's size > retOffset")
		methodRet := add(methodFrame, methodABI.retOffset, "methodFrame's size > retOffset")
		// This copies to the stack. Write barriers are not needed.
		memmove(valueRet, methodRet, retSize)
	}