dart::compiler::ffi::ArgumentAllocator Class Reference

Inheritance diagram for dart::compiler::ffi::ArgumentAllocator:

Public Member Functions
	ArgumentAllocator (Zone *zone, bool has_varargs)
const NativeLocation &	AllocateArgumentVariadic (const NativeType &payload_type, bool is_first_vararg=false, bool is_vararg=false)
Public Member Functions inherited from dart::ValueObject
	ValueObject ()
	~ValueObject ()

Detailed Description

Definition at line 98 of file native_calling_convention.cc.

Constructor & Destructor Documentation

ArgumentAllocator()

dart::compiler::ffi::ArgumentAllocator::ArgumentAllocator ( Zone *  zone, bool  has_varargs  )

inlineexplicit

Definition at line 100 of file native_calling_convention.cc.

      : has_varargs_(has_varargs), zone_(zone) {}

Member Function Documentation

AllocateArgumentVariadic()

const NativeLocation & dart::compiler::ffi::ArgumentAllocator::AllocateArgumentVariadic ( const NativeType &  payload_type, bool  is_first_vararg = false, bool  is_vararg = false  )

inline

Definition at line 103 of file native_calling_convention.cc.

                                                                         {
#if defined(TARGET_ARCH_ARM64) &&                                              \
    (defined(DART_TARGET_OS_MACOS_IOS) || defined(DART_TARGET_OS_MACOS))
    if (is_first_vararg) {
      // Block all registers.
      BlockAllFpuRegisters();
      cpu_regs_used = CallingConventions::kNumArgRegs;
    }
#endif
#if defined(TARGET_ARCH_RISCV64) || defined(TARGET_ARCH_RISCV32)
    if (is_first_vararg) {
      // Block all FPU registers.
      BlockAllFpuRegisters();
    }
#endif
    const auto& result = AllocateArgument(payload_type, is_vararg);
#if defined(TARGET_ARCH_X64) && defined(DART_TARGET_OS_WINDOWS)
    if (has_varargs_) {
      if (result.IsRegisters()) {
        // If an integer register is used, block the corresponding xmm register.
        ASSERT(CallingConventions::kArgumentIntRegXorFpuReg);
      } else if (result.IsFpuRegisters()) {
        // If an xmm register is used, also the corresponding integer register.
        ASSERT(CallingConventions::kArgumentIntRegXorFpuReg);
        const auto& fpu_reg_location = result.AsFpuRegisters();
        const FpuRegisterKind kind = kQuadFpuReg;
        ASSERT(fpu_reg_location.fpu_reg_kind() == kind);
        FpuRegister fpu_register = fpu_reg_location.fpu_reg();
        const intptr_t reg_index = fpu_register;
        ASSERT(cpu_regs_used == reg_index + 1);
        Register cpu_register =
            CallingConventions::ArgumentRegisters[reg_index];
        const auto& container_type = ConvertFloatToInt(zone_, payload_type);
        const auto& cpu_reg_location = *new (zone_) NativeRegistersLocation(
            zone_, payload_type, container_type, cpu_register);
        return *new (zone_)
            BothNativeLocations(fpu_reg_location, cpu_reg_location);
      }
    }
#endif
    return result;
  }

---

The documentation for this class was generated from the following file:

• third_party/dart-lang/sdk/runtime/vm/compiler/ffi/native_calling_convention.cc